/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.sf.refactorit.parser;

/**
 *
 * @author Heliomar
 */
import rantlr.ASTFactory;
import rantlr.ASTPair;
import rantlr.NoViableAltException;
import rantlr.ParserSharedInputState;
import rantlr.RecognitionException;
import rantlr.SemanticException;
import rantlr.Token;
import rantlr.TokenBuffer;
import rantlr.TokenStream;
import rantlr.TokenStreamException;
import rantlr.collections.AST;
import rantlr.collections.impl.ASTArray;
import rantlr.collections.impl.BitSet;

public class JavaRecognizer extends OptimizedJavaRecognizer
        implements JavaTokenTypes {

    private int ltCounter = 0;
    public static final String[] _tokenNames = {"<0>", "EOF", "<2>", "NULL_TREE_LOOKAHEAD", "BLOCK", "MODIFIERS", "OBJBLOCK", "SLIST", "CTOR_DEF", "METHOD_DEF", "VARIABLE_DEF", "INSTANCE_INIT", "STATIC_INIT", "TYPE", "CLASS_DEF", "INTERFACE_DEF", "PACKAGE_DEF", "ARRAY_DECLARATOR", "EXTENDS_CLAUSE", "IMPLEMENTS_CLAUSE", "PARAMETERS", "PARAMETER_DEF", "LABELED_STAT", "TYPECAST", "INDEX_OP", "POST_INC", "POST_DEC", "METHOD_CALL", "EXPR", "ARRAY_INIT", "IMPORT", "UNARY_MINUS", "UNARY_PLUS", "CASE_GROUP", "ELIST", "FOR_INIT", "FOR_CONDITION", "FOR_ITERATOR", "EMPTY_STAT", "\"final\"", "\"abstract\"", "\"strictfp\"", "SUPER_CTOR_CALL", "CTOR_CALL", "VARIABLE_PARAMETER_DEF", "STATIC_IMPORT", "ENUM_DEF", "ENUM_CONSTANT_DEF", "FOR_EACH_CLAUSE", "ANNOTATION_DEF", "ANNOTATIONS", "ANNOTATION", "ANNOTATION_MEMBER_VALUE_PAIR", "ANNOTATION_FIELD_DEF", "ANNOTATION_ARRAY_INIT", "TYPE_ARGUMENTS", "TYPE_ARGUMENT", "TYPE_PARAMETERS", "TYPE_PARAMETER", "WILDCARD_TYPE", "TYPE_UPPER_BOUNDS", "TYPE_LOWER_BOUNDS", "\"package\"", "SEMI", "\"import\"", "\"static\"", "LBRACK", "RBRACK", "IDENT", "DOT", "QUESTION", "\"extends\"", "\"super\"", "LT", "COMMA", "GT", "SR", "BSR", "\"void\"", "\"boolean\"", "\"byte\"", "\"char\"", "\"short\"", "\"int\"", "\"float\"", "\"long\"", "\"double\"", "STAR", "\"private\"", "\"public\"", "\"protected\"", "\"transient\"", "\"native\"", "\"synchronized\"", "\"volatile\"", "AT", "LPAREN", "RPAREN", "ASSIGN", "LCURLY", "RCURLY", "\"class\"", "\"interface\"", "\"enum\"", "BAND", "\"default\"", "\"implements\"", "\"this\"", "\"throws\"", "TRIPLE_DOT", "COLON", "\"if\"", "\"else\"", "\"while\"", "\"do\"", "\"break\"", "\"continue\"", "\"return\"", "\"switch\"", "\"throw\"", "\"assert\"", "\"for\"", "\"case\"", "\"try\"", "\"finally\"", "\"catch\"", "PLUS_ASSIGN", "MINUS_ASSIGN", "STAR_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "SR_ASSIGN", "BSR_ASSIGN", "SL_ASSIGN", "BAND_ASSIGN", "BXOR_ASSIGN", "BOR_ASSIGN", "LOR", "LAND", "BOR", "BXOR", "NOT_EQUAL", "EQUAL", "LE", "GE", "\"instanceof\"", "SL", "PLUS", "MINUS", "DIV", "MOD", "INC", "DEC", "BNOT", "LNOT", "\"true\"", "\"false\"", "\"null\"", "\"new\"", "NUM_INT", "CHAR_LITERAL", "STRING_LITERAL", "NUM_FLOAT", "NUM_LONG", "NUM_DOUBLE", "WS", "SL_COMMENT", "ML_COMMENT", "ESC", "HEX_DIGIT", "VOCAB", "EXPONENT", "FLOAT_SUFFIX", "UNICODE_EOF"};
    private static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
    private static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
    private static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
    private static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
    private static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
    private static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
    private static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
    private static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
    private static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
    private static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
    private static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
    private static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
    private static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
    private static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
    private static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
    private static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
    private static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
    private static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
    private static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
    private static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
    private static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
    private static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
    private static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
    private static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
    private static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
    private static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
    private static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
    private static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
    private static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
    private static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
    private static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
    private static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
    private static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
    private static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
    private static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
    private static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
    private static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
    private static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
    private static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
    private static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
    private static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
    private static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
    private static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
    private static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
    private static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
    private static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
    private static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
    private static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
    private static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
    private static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
    private static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
    private static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
    private static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
    private static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
    private static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
    private static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
    private static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
    private static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
    private static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
    private static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
    private static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
    private static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
    private static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
    private static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
    private static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
    private static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
    private static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
    private static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
    private static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
    private static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
    private static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
    private static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
    private static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
    private static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
    private static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
    private static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
    private static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
    private static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
    private static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
    private static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
    private static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80());
    private static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81());
    private static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82());
    private static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83());
    private static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84());
    private static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85());
    private static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86());
    private static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87());
    private static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88());
    private static final BitSet _tokenSet_89 = new BitSet(mk_tokenSet_89());
    private static final BitSet _tokenSet_90 = new BitSet(mk_tokenSet_90());
    private static final BitSet _tokenSet_91 = new BitSet(mk_tokenSet_91());
    private static final BitSet _tokenSet_92 = new BitSet(mk_tokenSet_92());
    private static final BitSet _tokenSet_93 = new BitSet(mk_tokenSet_93());
    private static final BitSet _tokenSet_94 = new BitSet(mk_tokenSet_94());

    public void setLineColumn(Token firstToken, ASTImpl ast)
            throws TokenStreamException {
        try {
            ast.setColumn(firstToken.getColumn());
            ast.setLine(firstToken.getLine());
            TokenExt lastToken = (TokenExt) LT(0);
            ast.setEndColumn(lastToken.getEndColumn());
            ast.setEndLine(lastToken.getEndLine());
        } catch (NullPointerException e) {
        }
    }

    public void setLineColumnAll(Token firstToken, ASTImpl ast) throws TokenStreamException {
        AST nextAst;
        try {
            ast.setColumn(firstToken.getColumn());
            ast.setLine(firstToken.getLine());
            TokenExt lastToken = (TokenExt) LT(0);
            ast.setEndColumn(lastToken.getEndColumn());
            ast.setEndLine(lastToken.getEndLine());

            for (nextAst = ast.getNextSibling(); nextAst != null;) {
                ASTImpl changeAst = (ASTImpl) nextAst;
                changeAst.setColumn(firstToken.getColumn());
                changeAst.setLine(firstToken.getLine());
                changeAst.setEndColumn(ast.getEndColumn());
                changeAst.setEndLine(ast.getEndLine());

                nextAst = nextAst.getNextSibling();
            }
        } catch (NullPointerException e) {
        }
    }

    protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
        super(tokenBuf, k);
        this.tokenNames = _tokenNames;
        buildTokenTypeASTClassMap();
        this.astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    public JavaRecognizer(TokenBuffer tokenBuf) {
        this(tokenBuf, 2);
    }

    protected JavaRecognizer(TokenStream lexer, int k) {
        super(lexer, k);
        this.tokenNames = _tokenNames;
        buildTokenTypeASTClassMap();
        this.astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    public JavaRecognizer(TokenStream lexer) {
        this(lexer, 2);
    }

    public JavaRecognizer(ParserSharedInputState state) {
        super(state, 2);
        this.tokenNames = _tokenNames;
        buildTokenTypeASTClassMap();
        this.astFactory = new ASTFactory(getTokenTypeToASTClassMap());
    }

    public final void compilationUnit() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST compilationUnit_AST = null;
            try {
                boolean synPredMatched4 = false;
                if ((((this.mLA1 == 62) || (this.mLA1 == 95))) && (LA(2) == 68)) {
                    int _m4 = mark();
                    synPredMatched4 = true;
                    this.inputState.guessing += 1;
                    try {
                        annotations();
                        match(62);
                    } catch (RecognitionException pe) {
                        synPredMatched4 = false;
                    }
                    rewind(_m4);
                    this.inputState.guessing -= 1;
                }
                if (synPredMatched4) {
                    packageDefinition();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((!_tokenSet_0.member(this.mLA1)) || (!_tokenSet_1.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                while (this.mLA1 == 64) {
                    importDefinition();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                while (_tokenSet_2.member(this.mLA1)) {
                    typeDefinition();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                AST tmp1_AST = null;
                tmp1_AST = this.astFactory.create(LT(1));
                this.astFactory.addASTChild(currentAST, tmp1_AST);
                match(1);

                compilationUnit_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_3);
                } else {
                    throw ex;
                }
            }
            this.returnAST = compilationUnit_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotations() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotations_AST = null;
            try {
                while (this.mLA1 == 95) {
                    annotation();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    annotations_AST = currentAST.root;
                    annotations_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(50, "ANNOTATIONS")).add(annotations_AST));
                    currentAST.root = annotations_AST;
                    currentAST.child = (((annotations_AST != null) && (annotations_AST.getFirstChild() != null)) ? annotations_AST.getFirstChild() : annotations_AST);

                    currentAST.advanceChildToEnd();
                }
                annotations_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_4);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotations_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void packageDefinition() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST packageDefinition_AST = null;
            Token p = null;
            AST p_AST = null;
            try {
                annotations();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                p = LT(1);
                p_AST = this.astFactory.create(p);
                this.astFactory.makeASTRoot(currentAST, p_AST);
                match(62);
                if (this.inputState.guessing == 0) {
                    p_AST.setType(16);
                }
                identifier();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(63);
                packageDefinition_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_0);
                } else {
                    throw ex;
                }
            }
            this.returnAST = packageDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void importDefinition() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST importDefinition_AST = null;
            Token i = null;
            AST i_AST = null;
            boolean isStatic = false;
            try {
                i = LT(1);
                i_AST = this.astFactory.create(i);
                this.astFactory.makeASTRoot(currentAST, i_AST);
                match(64);
                if (this.inputState.guessing == 0) {
                    i_AST.setType(30);
                }

                switch (this.mLA1) {
                    case 65:
                        match(65);
                        if (this.inputState.guessing == 0) {
                            i_AST.setType(45);
                        }
                        break;
                    case 68:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                identifierStar();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(63);
                importDefinition_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_0);
                } else {
                    throw ex;
                }
            }
            this.returnAST = importDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeDefinition() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeDefinition_AST = null;
            AST m_AST = null;
            Token firstToken = LT(1);
            try {
                switch (this.mLA1) {
                    case 39:
                    case 40:
                    case 41:
                    case 65:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                        modifiers();
                        m_AST = this.returnAST;
                        typeDefinitionInternal(m_AST, firstToken);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeDefinition_AST = currentAST.root;
                        break;
                    case 63:
                        match(63);
                        typeDefinition_AST = currentAST.root;
                        break;
                    case 42:
                    case 43:
                    case 44:
                    case 45:
                    case 46:
                    case 47:
                    case 48:
                    case 49:
                    case 50:
                    case 51:
                    case 52:
                    case 53:
                    case 54:
                    case 55:
                    case 56:
                    case 57:
                    case 58:
                    case 59:
                    case 60:
                    case 61:
                    case 62:
                    case 64:
                    case 66:
                    case 67:
                    case 68:
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 87:
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_5);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void identifier() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST identifier_AST = null;
            try {
                AST tmp6_AST = null;
                tmp6_AST = this.astFactory.create(LT(1));
                this.astFactory.addASTChild(currentAST, tmp6_AST);
                match(68);

                while (this.mLA1 == 69) {
                    AST tmp7_AST = null;
                    tmp7_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp7_AST);
                    match(69);
                    AST tmp8_AST = null;
                    tmp8_AST = this.astFactory.create(LT(1));
                    this.astFactory.addASTChild(currentAST, tmp8_AST);
                    match(68);
                }

                identifier_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_6);
                } else {
                    throw ex;
                }
            }
            this.returnAST = identifier_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void identifierStar() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST identifierStar_AST = null;
            try {
                AST tmp9_AST = null;
                tmp9_AST = this.astFactory.create(LT(1));
                this.astFactory.addASTChild(currentAST, tmp9_AST);
                match(68);

                while ((this.mLA1 == 69) && (LA(2) == 68)) {
                    AST tmp10_AST = null;
                    tmp10_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp10_AST);
                    match(69);
                    AST tmp11_AST = null;
                    tmp11_AST = this.astFactory.create(LT(1));
                    this.astFactory.addASTChild(currentAST, tmp11_AST);
                    match(68);
                }

                switch (this.mLA1) {
                    case 69:
                        AST tmp12_AST = null;
                        tmp12_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp12_AST);
                        match(69);
                        AST tmp13_AST = null;
                        tmp13_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp13_AST);
                        match(87);
                        break;
                    case 63:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                identifierStar_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = identifierStar_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void modifiers() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST modifiers_AST = null;
            try {
                while (true) {
                    if (_tokenSet_8.member(this.mLA1)) {
                        modifier();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                    }
                    if ((this.mLA1 != 95) || (LA(2) != 68) || (this.mLA1 != 95) || (LT(2).getText().equals("interface"))) {
                        break;
                    }
                    annotation();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    modifiers_AST = currentAST.root;
                    modifiers_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(5, "MODIFIERS")).add(modifiers_AST));
                    currentAST.root = modifiers_AST;
                    currentAST.child = (((modifiers_AST != null) && (modifiers_AST.getFirstChild() != null)) ? modifiers_AST.getFirstChild() : modifiers_AST);

                    currentAST.advanceChildToEnd();
                }
                modifiers_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_9);
                } else {
                    throw ex;
                }
            }
            this.returnAST = modifiers_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    protected final void typeDefinitionInternal(AST mods, Token firstToken) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeDefinitionInternal_AST = null;
            try {
                switch (this.mLA1) {
                    case 101:
                        classDefinition(mods, firstToken);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeDefinitionInternal_AST = currentAST.root;
                        break;
                    case 102:
                        interfaceDefinition(mods, firstToken);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeDefinitionInternal_AST = currentAST.root;
                        break;
                    case 103:
                        enumDefinition(mods, firstToken);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeDefinitionInternal_AST = currentAST.root;
                        break;
                    case 95:
                        annotationDefinition(mods, firstToken);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeDefinitionInternal_AST = currentAST.root;
                        break;
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeDefinitionInternal_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void classDefinition(AST modifiers, Token firstToken) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST classDefinition_AST = null;
            AST tp_AST = null;
            AST sc_AST = null;
            AST ic_AST = null;
            AST cb_AST = null;
            try {
                match(101);
                AST tmp15_AST = null;
                tmp15_AST = this.astFactory.create(LT(1));
                match(68);

                switch (this.mLA1) {
                    case 73:
                        typeParameters();
                        tp_AST = this.returnAST;
                        break;
                    case 71:
                    case 99:
                    case 106:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                superClassClause();
                sc_AST = this.returnAST;
                implementsClause();
                ic_AST = this.returnAST;
                classBlock();
                cb_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    classDefinition_AST = currentAST.root;
                    classDefinition_AST = this.astFactory.make(new ASTArray(7).add(this.astFactory.create(14, "CLASS_DEF")).add(modifiers).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
                    currentAST.root = classDefinition_AST;
                    currentAST.child = (((classDefinition_AST != null) && (classDefinition_AST.getFirstChild() != null)) ? classDefinition_AST.getFirstChild() : classDefinition_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    classDefinition_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) classDefinition_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_11);
                } else {
                    throw ex;
                }
            }
            this.returnAST = classDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void interfaceDefinition(AST modifiers, Token firstToken) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST interfaceDefinition_AST = null;
            AST tp_AST = null;
            AST ie_AST = null;
            AST ib_AST = null;
            try {
                match(102);
                AST tmp17_AST = null;
                tmp17_AST = this.astFactory.create(LT(1));
                match(68);

                switch (this.mLA1) {
                    case 73:
                        typeParameters();
                        tp_AST = this.returnAST;
                        break;
                    case 71:
                    case 99:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                interfaceExtends();
                ie_AST = this.returnAST;
                interfaceBlock();
                ib_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    interfaceDefinition_AST = currentAST.root;
                    interfaceDefinition_AST = this.astFactory.make(new ASTArray(6).add(this.astFactory.create(15, "INTERFACE_DEF")).add(modifiers).add(tmp17_AST).add(tp_AST).add(ie_AST).add(ib_AST));
                    currentAST.root = interfaceDefinition_AST;
                    currentAST.child = (((interfaceDefinition_AST != null) && (interfaceDefinition_AST.getFirstChild() != null)) ? interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    interfaceDefinition_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) interfaceDefinition_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = interfaceDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void enumDefinition(AST modifiers, Token firstToken) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST enumDefinition_AST = null;
            AST ic_AST = null;
            AST eb_AST = null;
            try {
                match(103);
                AST tmp19_AST = null;
                tmp19_AST = this.astFactory.create(LT(1));
                match(68);
                implementsClause();
                ic_AST = this.returnAST;
                enumBlock();
                eb_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    enumDefinition_AST = currentAST.root;
                    enumDefinition_AST = this.astFactory.make(new ASTArray(5).add(this.astFactory.create(46, "ENUM_DEF")).add(modifiers).add(tmp19_AST).add(ic_AST).add(eb_AST));
                    currentAST.root = enumDefinition_AST;
                    currentAST.child = (((enumDefinition_AST != null) && (enumDefinition_AST.getFirstChild() != null)) ? enumDefinition_AST.getFirstChild() : enumDefinition_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    enumDefinition_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) enumDefinition_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = enumDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationDefinition(AST modifiers, Token firstToken) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationDefinition_AST = null;
            AST ab_AST = null;
            try {
                AST tmp20_AST = null;
                tmp20_AST = this.astFactory.create(LT(1));
                match(95);
                match(102);
                AST tmp22_AST = null;
                tmp22_AST = this.astFactory.create(LT(1));
                match(68);
                annotationBlock();
                ab_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    annotationDefinition_AST = currentAST.root;
                    annotationDefinition_AST = this.astFactory.make(new ASTArray(4).add(this.astFactory.create(49, "ANNOTATION_DEF")).add(modifiers).add(tmp22_AST).add(ab_AST));
                    currentAST.root = annotationDefinition_AST;
                    currentAST.child = (((annotationDefinition_AST != null) && (annotationDefinition_AST.getFirstChild() != null)) ? annotationDefinition_AST.getFirstChild() : annotationDefinition_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    annotationDefinition_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) annotationDefinition_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationDefinition_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void declaration() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST declaration_AST = null;
            AST m_AST = null;
            AST t_AST = null;
            AST v_AST = null;
            Token firstToken = LT(1);
            try {
                modifiers();
                m_AST = this.returnAST;
                typeSpec(false);
                t_AST = this.returnAST;
                variableDefinitions(m_AST, t_AST);
                v_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    declaration_AST = currentAST.root;
                    declaration_AST = v_AST;
                    setLineColumnAll(firstToken, (ASTImpl) declaration_AST);
                    currentAST.root = declaration_AST;
                    currentAST.child = (((declaration_AST != null) && (declaration_AST.getFirstChild() != null)) ? declaration_AST.getFirstChild() : declaration_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = declaration_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeSpec(boolean addImagNode) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeSpec_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                        classTypeSpec(addImagNode);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeSpec_AST = currentAST.root;
                        break;
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        builtInTypeSpec(addImagNode);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeSpec_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_12);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeSpec_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void variableDefinitions(AST mods, AST t) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST variableDefinitions_AST = null;
            try {
                variableDeclarator(getASTFactory().dupTree(mods), getASTFactory().dupTree(t));

                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 74) {
                    match(74);
                    variableDeclarator(getASTFactory().dupTree(mods), getASTFactory().dupTree(t));

                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                variableDefinitions_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = variableDefinitions_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void classTypeSpec(boolean addImagNode) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST classTypeSpec_AST = null;
            Token lb = null;
            AST lb_AST = null;
            Token firstToken = LT(1);
            try {
                classOrInterfaceType(false);
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while ((this.mLA1 == 66) && (LA(2) == 67)) {
                    lb = LT(1);
                    lb_AST = this.astFactory.create(lb);
                    this.astFactory.makeASTRoot(currentAST, lb_AST);
                    match(66);
                    if (this.inputState.guessing == 0) {
                        lb_AST.setType(17);
                    }
                    match(67);
                }

                if (this.inputState.guessing == 0) {
                    classTypeSpec_AST = currentAST.root;

                    if (addImagNode) {
                        classTypeSpec_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(classTypeSpec_AST));
                        setLineColumn(firstToken, (ASTImpl) classTypeSpec_AST);
                    }

                    currentAST.root = classTypeSpec_AST;
                    currentAST.child = (((classTypeSpec_AST != null) && (classTypeSpec_AST.getFirstChild() != null)) ? classTypeSpec_AST.getFirstChild() : classTypeSpec_AST);

                    currentAST.advanceChildToEnd();
                }
                classTypeSpec_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = classTypeSpec_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void builtInTypeSpec(boolean addImagNode) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST builtInTypeSpec_AST = null;
            Token lb = null;
            AST lb_AST = null;
            Token firstToken = LT(1);
            try {
                builtInType();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 66) {
                    lb = LT(1);
                    lb_AST = this.astFactory.create(lb);
                    this.astFactory.makeASTRoot(currentAST, lb_AST);
                    match(66);
                    if (this.inputState.guessing == 0) {
                        lb_AST.setType(17);
                    }
                    match(67);
                }

                if (this.inputState.guessing == 0) {
                    builtInTypeSpec_AST = currentAST.root;

                    if (addImagNode) {
                        builtInTypeSpec_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(builtInTypeSpec_AST));
                        setLineColumn(firstToken, (ASTImpl) builtInTypeSpec_AST);
                    }

                    currentAST.root = builtInTypeSpec_AST;
                    currentAST.child = (((builtInTypeSpec_AST != null) && (builtInTypeSpec_AST.getFirstChild() != null)) ? builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST);

                    currentAST.advanceChildToEnd();
                }
                builtInTypeSpec_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_12);
                } else {
                    throw ex;
                }
            }
            this.returnAST = builtInTypeSpec_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void classOrInterfaceType(boolean addImagNode) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST classOrInterfaceType_AST = null;
            try {
                AST tmp26_AST = null;
                tmp26_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp26_AST);
                match(68);

                switch (this.mLA1) {
                    case 73:
                        typeArguments();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                    case 66:
                    case 67:
                    case 68:
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 104:
                    case 106:
                    case 107:
                    case 109:
                    case 110:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                        break;
                    case 64:
                    case 65:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                    case 105:
                    case 108:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                while ((this.mLA1 == 69) && (LA(2) == 68)) {
                    AST tmp27_AST = null;
                    tmp27_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp27_AST);
                    match(69);
                    AST tmp28_AST = null;
                    tmp28_AST = this.astFactory.create(LT(1));
                    this.astFactory.addASTChild(currentAST, tmp28_AST);
                    match(68);

                    switch (this.mLA1) {
                        case 73:
                            typeArguments();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            break;
                        case 63:
                        case 66:
                        case 67:
                        case 68:
                        case 69:
                        case 70:
                        case 71:
                        case 72:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 96:
                        case 97:
                        case 98:
                        case 99:
                        case 100:
                        case 104:
                        case 106:
                        case 107:
                        case 109:
                        case 110:
                        case 126:
                        case 127:
                        case 128:
                        case 129:
                        case 130:
                        case 131:
                        case 132:
                        case 133:
                        case 134:
                        case 135:
                        case 136:
                        case 137:
                        case 138:
                        case 139:
                        case 140:
                        case 141:
                        case 142:
                            break;
                        case 64:
                        case 65:
                        case 87:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 101:
                        case 102:
                        case 103:
                        case 105:
                        case 108:
                        case 111:
                        case 112:
                        case 113:
                        case 114:
                        case 115:
                        case 116:
                        case 117:
                        case 118:
                        case 119:
                        case 120:
                        case 121:
                        case 122:
                        case 123:
                        case 124:
                        case 125:
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                }

                if (this.inputState.guessing == 0) {
                    classOrInterfaceType_AST = currentAST.root;

                    if (addImagNode) {
                        classOrInterfaceType_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(classOrInterfaceType_AST));
                    }

                    currentAST.root = classOrInterfaceType_AST;
                    currentAST.child = (((classOrInterfaceType_AST != null) && (classOrInterfaceType_AST.getFirstChild() != null)) ? classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST);

                    currentAST.advanceChildToEnd();
                }
                classOrInterfaceType_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = classOrInterfaceType_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeArguments() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeArguments_AST = null;
            int currentLtLevel = 0;
            Token firstToken = LT(1);
            try {
                if (this.inputState.guessing == 0) {
                    currentLtLevel = this.ltCounter;
                }
                match(73);
                if (this.inputState.guessing == 0) {
                    this.ltCounter += 1;
                }
                typeArgument();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while ((this.mLA1 == 74) && (_tokenSet_14.member(LA(2))) && (((this.inputState.guessing != 0) || (this.ltCounter == currentLtLevel + 1)))) {
                    match(74);
                    typeArgument();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if ((this.mLA1 >= 75) && (this.mLA1 <= 77) && (_tokenSet_13.member(LA(2)))) {
                    typeArgumentsOrParametersEnd();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((!_tokenSet_13.member(this.mLA1)) || (!_tokenSet_15.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                if ((currentLtLevel == 0) && (this.ltCounter != currentLtLevel)) {
                    throw new SemanticException("currentLtLevel != 0 || ltCounter == currentLtLevel");
                }
                if (this.inputState.guessing == 0) {
                    typeArguments_AST = currentAST.root;
                    typeArguments_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(55, "TYPE_ARGUMENTS")).add(typeArguments_AST));
                    setLineColumn(firstToken, (ASTImpl) typeArguments_AST);
                    currentAST.root = typeArguments_AST;
                    currentAST.child = (((typeArguments_AST != null) && (typeArguments_AST.getFirstChild() != null)) ? typeArguments_AST.getFirstChild() : typeArguments_AST);

                    currentAST.advanceChildToEnd();
                }
                typeArguments_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeArguments_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeArgumentSpec() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeArgumentSpec_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                        classTypeSpec(true);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeArgumentSpec_AST = currentAST.root;
                        break;
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        builtInTypeArraySpec(true);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        typeArgumentSpec_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeArgumentSpec_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void builtInTypeArraySpec(boolean addImagNode) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST builtInTypeArraySpec_AST = null;
            Token lb = null;
            AST lb_AST = null;
            Token firstToken = LT(1);
            try {
                builtInType();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                int _cnt41 = 0;
                while (true) {
                    if ((this.mLA1 == 66) && (LA(2) == 67)) {
                        lb = LT(1);
                        lb_AST = this.astFactory.create(lb);
                        this.astFactory.makeASTRoot(currentAST, lb_AST);
                        match(66);
                        if (this.inputState.guessing == 0) {
                            lb_AST.setType(17);
                        }
                        match(67);
                    } else {
                        if (_cnt41 >= 1) {
                            break;
                        }
                        throw new NoViableAltException(LT(1), getFilename());
                    }

                    ++_cnt41;
                }

                if (this.inputState.guessing == 0) {
                    builtInTypeArraySpec_AST = currentAST.root;

                    if (addImagNode) {
                        builtInTypeArraySpec_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(builtInTypeArraySpec_AST));
                        setLineColumn(firstToken, (ASTImpl) builtInTypeArraySpec_AST);
                    }

                    currentAST.root = builtInTypeArraySpec_AST;
                    currentAST.child = (((builtInTypeArraySpec_AST != null) && (builtInTypeArraySpec_AST.getFirstChild() != null)) ? builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST);

                    currentAST.advanceChildToEnd();
                }
                builtInTypeArraySpec_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = builtInTypeArraySpec_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeArgument() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeArgument_AST = null;
            Token firstToken = LT(1);
            try {
                switch (this.mLA1) {
                    case 68:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        typeArgumentSpec();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 70:
                        wildcardType();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 69:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    typeArgument_AST = currentAST.root;
                    typeArgument_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(56, "TYPE_ARGUMENT")).add(typeArgument_AST));
                    setLineColumn(firstToken, (ASTImpl) typeArgument_AST);
                    currentAST.root = typeArgument_AST;
                    currentAST.child = (((typeArgument_AST != null) && (typeArgument_AST.getFirstChild() != null)) ? typeArgument_AST.getFirstChild() : typeArgument_AST);

                    currentAST.advanceChildToEnd();
                }
                typeArgument_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeArgument_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void wildcardType() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST wildcardType_AST = null;
            Token q = null;
            AST q_AST = null;
            try {
                q = LT(1);
                q_AST = this.astFactory.create(q);
                this.astFactory.makeASTRoot(currentAST, q_AST);
                match(70);
                if (this.inputState.guessing == 0) {
                    q_AST.setType(59);
                }

                boolean synPredMatched31 = false;
                if ((((this.mLA1 == 71) || (this.mLA1 == 72))) && (LA(2) == 68)) {
                    int _m31 = mark();
                    synPredMatched31 = true;
                    this.inputState.guessing += 1;
                    try {
                        switch (this.mLA1) {
                            case 71:
                                match(71);
                                break;
                            case 72:
                                match(72);
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                    } catch (RecognitionException pe) {
                        synPredMatched31 = false;
                    }
                    rewind(_m31);
                    this.inputState.guessing -= 1;
                }
                if (synPredMatched31) {
                    typeArgumentBounds();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((!_tokenSet_13.member(this.mLA1)) || (!_tokenSet_15.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                wildcardType_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = wildcardType_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeArgumentBounds() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeArgumentBounds_AST = null;
            boolean isUpperBounds = false;
            try {
                switch (this.mLA1) {
                    case 71:
                        match(71);
                        if (this.inputState.guessing == 0) {
                            isUpperBounds = true;
                        }
                        break;
                    case 72:
                        match(72);
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                classTypeSpec(false);
                this.astFactory.addASTChild(currentAST, this.returnAST);
                if (this.inputState.guessing == 0) {
                    typeArgumentBounds_AST = currentAST.root;

                    if (isUpperBounds) {
                        typeArgumentBounds_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(60, "TYPE_UPPER_BOUNDS")).add(typeArgumentBounds_AST));
                    } else {
                        typeArgumentBounds_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(61, "TYPE_LOWER_BOUNDS")).add(typeArgumentBounds_AST));
                    }

                    currentAST.root = typeArgumentBounds_AST;
                    currentAST.child = (((typeArgumentBounds_AST != null) && (typeArgumentBounds_AST.getFirstChild() != null)) ? typeArgumentBounds_AST.getFirstChild() : typeArgumentBounds_AST);

                    currentAST.advanceChildToEnd();
                }
                typeArgumentBounds_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeArgumentBounds_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeArgumentsOrParametersEnd_AST = null;
            try {
                switch (this.mLA1) {
                    case 75:
                        match(75);
                        if (this.inputState.guessing == 0) {
                            this.ltCounter -= 1;
                        }
                        typeArgumentsOrParametersEnd_AST = currentAST.root;
                        break;
                    case 76:
                        match(76);
                        if (this.inputState.guessing == 0) {
                            this.ltCounter -= 2;
                        }
                        typeArgumentsOrParametersEnd_AST = currentAST.root;
                        break;
                    case 77:
                        match(77);
                        if (this.inputState.guessing == 0) {
                            this.ltCounter -= 3;
                        }
                        typeArgumentsOrParametersEnd_AST = currentAST.root;
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_13);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeArgumentsOrParametersEnd_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void builtInType() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST builtInType_AST = null;
            try {
                switch (this.mLA1) {
                    case 78:
                        AST tmp37_AST = null;
                        tmp37_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp37_AST);
                        match(78);
                        builtInType_AST = currentAST.root;
                        break;
                    case 79:
                        AST tmp38_AST = null;
                        tmp38_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp38_AST);
                        match(79);
                        builtInType_AST = currentAST.root;
                        break;
                    case 80:
                        AST tmp39_AST = null;
                        tmp39_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp39_AST);
                        match(80);
                        builtInType_AST = currentAST.root;
                        break;
                    case 81:
                        AST tmp40_AST = null;
                        tmp40_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp40_AST);
                        match(81);
                        builtInType_AST = currentAST.root;
                        break;
                    case 82:
                        AST tmp41_AST = null;
                        tmp41_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp41_AST);
                        match(82);
                        builtInType_AST = currentAST.root;
                        break;
                    case 83:
                        AST tmp42_AST = null;
                        tmp42_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp42_AST);
                        match(83);
                        builtInType_AST = currentAST.root;
                        break;
                    case 84:
                        AST tmp43_AST = null;
                        tmp43_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp43_AST);
                        match(84);
                        builtInType_AST = currentAST.root;
                        break;
                    case 85:
                        AST tmp44_AST = null;
                        tmp44_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp44_AST);
                        match(85);
                        builtInType_AST = currentAST.root;
                        break;
                    case 86:
                        AST tmp45_AST = null;
                        tmp45_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp45_AST);
                        match(86);
                        builtInType_AST = currentAST.root;
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_16);
                } else {
                    throw ex;
                }
            }
            this.returnAST = builtInType_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void type() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST type_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                        classOrInterfaceType(false);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        type_AST = currentAST.root;
                        break;
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        builtInType();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        type_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_17);
                } else {
                    throw ex;
                }
            }
            this.returnAST = type_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void modifier() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST modifier_AST = null;
            try {
                switch (this.mLA1) {
                    case 88:
                        AST tmp46_AST = null;
                        tmp46_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp46_AST);
                        match(88);
                        modifier_AST = currentAST.root;
                        break;
                    case 89:
                        AST tmp47_AST = null;
                        tmp47_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp47_AST);
                        match(89);
                        modifier_AST = currentAST.root;
                        break;
                    case 90:
                        AST tmp48_AST = null;
                        tmp48_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp48_AST);
                        match(90);
                        modifier_AST = currentAST.root;
                        break;
                    case 65:
                        AST tmp49_AST = null;
                        tmp49_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp49_AST);
                        match(65);
                        modifier_AST = currentAST.root;
                        break;
                    case 91:
                        AST tmp50_AST = null;
                        tmp50_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp50_AST);
                        match(91);
                        modifier_AST = currentAST.root;
                        break;
                    case 39:
                        AST tmp51_AST = null;
                        tmp51_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp51_AST);
                        match(39);
                        modifier_AST = currentAST.root;
                        break;
                    case 40:
                        AST tmp52_AST = null;
                        tmp52_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp52_AST);
                        match(40);
                        modifier_AST = currentAST.root;
                        break;
                    case 92:
                        AST tmp53_AST = null;
                        tmp53_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp53_AST);
                        match(92);
                        modifier_AST = currentAST.root;
                        break;
                    case 93:
                        AST tmp54_AST = null;
                        tmp54_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp54_AST);
                        match(93);
                        modifier_AST = currentAST.root;
                        break;
                    case 94:
                        AST tmp55_AST = null;
                        tmp55_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp55_AST);
                        match(94);
                        modifier_AST = currentAST.root;
                        break;
                    case 41:
                        AST tmp56_AST = null;
                        tmp56_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp56_AST);
                        match(41);
                        modifier_AST = currentAST.root;
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_18);
                } else {
                    throw ex;
                }
            }
            this.returnAST = modifier_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotation() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotation_AST = null;
            AST i_AST = null;
            AST args_AST = null;
            try {
                match(95);
                identifier();
                i_AST = this.returnAST;

                switch (this.mLA1) {
                    case 96:
                        match(96);

                        switch (this.mLA1) {
                            case 68:
                            case 72:
                            case 73:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 95:
                            case 96:
                            case 99:
                            case 107:
                            case 147:
                            case 148:
                            case 151:
                            case 152:
                            case 153:
                            case 154:
                            case 155:
                            case 156:
                            case 157:
                            case 158:
                            case 159:
                            case 160:
                            case 161:
                            case 162:
                            case 163:
                            case 164:
                                annotationArguments();
                                args_AST = this.returnAST;
                                break;
                            case 97:
                                break;
                            case 69:
                            case 70:
                            case 71:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 98:
                            case 100:
                            case 101:
                            case 102:
                            case 103:
                            case 104:
                            case 105:
                            case 106:
                            case 108:
                            case 109:
                            case 110:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 149:
                            case 150:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(97);
                        break;
                    case 39:
                    case 40:
                    case 41:
                    case 62:
                    case 63:
                    case 65:
                    case 68:
                    case 73:
                    case 74:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                        break;
                    case 42:
                    case 43:
                    case 44:
                    case 45:
                    case 46:
                    case 47:
                    case 48:
                    case 49:
                    case 50:
                    case 51:
                    case 52:
                    case 53:
                    case 54:
                    case 55:
                    case 56:
                    case 57:
                    case 58:
                    case 59:
                    case 60:
                    case 61:
                    case 64:
                    case 66:
                    case 67:
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 98:
                    case 99:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    annotation_AST = currentAST.root;
                    annotation_AST = this.astFactory.make(new ASTArray(3).add(this.astFactory.create(51, "ANNOTATION")).add(i_AST).add(args_AST));
                    currentAST.root = annotation_AST;
                    currentAST.child = (((annotation_AST != null) && (annotation_AST.getFirstChild() != null)) ? annotation_AST.getFirstChild() : annotation_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_19);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotation_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationArguments() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationArguments_AST = null;
            try {
                if ((_tokenSet_20.member(this.mLA1)) && (_tokenSet_21.member(LA(2)))) {
                    annotationMemberValueInitializer();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                    annotationArguments_AST = currentAST.root;
                } else if ((this.mLA1 == 68) && (LA(2) == 98)) {
                    annotationMemberValuePairs();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                    annotationArguments_AST = currentAST.root;
                } else {
                    throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationArguments_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberValueInitializer_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        conditionalExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        annotationMemberValueInitializer_AST = currentAST.root;
                        break;
                    case 95:
                        annotation();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        annotationMemberValueInitializer_AST = currentAST.root;
                        break;
                    case 99:
                        annotationMemberArrayInitializer();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        annotationMemberValueInitializer_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 97:
                    case 98:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_23);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberValueInitializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberValuePairs_AST = null;
            try {
                annotationMemberValuePair();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 74) {
                    match(74);
                    annotationMemberValuePair();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                annotationMemberValuePairs_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberValuePairs_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberValuePair_AST = null;
            Token i = null;
            AST i_AST = null;
            AST v_AST = null;
            try {
                i = LT(1);
                i_AST = this.astFactory.create(i);
                match(68);
                match(98);
                annotationMemberValueInitializer();
                v_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    annotationMemberValuePair_AST = currentAST.root;
                    annotationMemberValuePair_AST = this.astFactory.make(new ASTArray(3).add(this.astFactory.create(52, "ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(v_AST));
                    currentAST.root = annotationMemberValuePair_AST;
                    currentAST.child = (((annotationMemberValuePair_AST != null) && (annotationMemberValuePair_AST.getFirstChild() != null)) ? annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_24);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberValuePair_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void conditionalExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST conditionalExpression_AST = null;
            try {
                logicalOrExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                switch (this.mLA1) {
                    case 70:
                        AST tmp62_AST = null;
                        tmp62_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp62_AST);
                        match(70);
                        assignmentExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(110);
                        conditionalExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                    case 67:
                    case 74:
                    case 97:
                    case 98:
                    case 100:
                    case 110:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                        break;
                    case 64:
                    case 65:
                    case 66:
                    case 68:
                    case 69:
                    case 71:
                    case 72:
                    case 73:
                    case 75:
                    case 76:
                    case 77:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 99:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 107:
                    case 108:
                    case 109:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                conditionalExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_25);
                } else {
                    throw ex;
                }
            }
            this.returnAST = conditionalExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberArrayInitializer_AST = null;
            Token lc = null;
            AST lc_AST = null;
            try {
                lc = LT(1);
                lc_AST = this.astFactory.create(lc);
                this.astFactory.makeASTRoot(currentAST, lc_AST);
                match(99);
                if (this.inputState.guessing == 0) {
                    lc_AST.setType(54);
                }

                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 95:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        annotationMemberArrayValueInitializer();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        while ((this.mLA1 == 74) && (_tokenSet_26.member(LA(2)))) {
                            match(74);
                            annotationMemberArrayValueInitializer();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }

                        switch (this.mLA1) {
                            case 74:
                                match(74);
                                break;
                            case 100:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 100:
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 97:
                    case 98:
                    case 99:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                match(100);
                annotationMemberArrayInitializer_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_23);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberArrayInitializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberArrayValueInitializer_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        annotationMemberArrayConditional();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        annotationMemberArrayValueInitializer_AST = currentAST.root;
                        break;
                    case 95:
                        annotation();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        annotationMemberArrayValueInitializer_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_27);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberArrayValueInitializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationMemberArrayConditional() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationMemberArrayConditional_AST = null;
            Token firstToken = LT(1);
            try {
                conditionalExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                if (this.inputState.guessing == 0) {
                    annotationMemberArrayConditional_AST = currentAST.root;
                    annotationMemberArrayConditional_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(28, "EXPR")).add(annotationMemberArrayConditional_AST));
                    currentAST.root = annotationMemberArrayConditional_AST;
                    currentAST.child = (((annotationMemberArrayConditional_AST != null) && (annotationMemberArrayConditional_AST.getFirstChild() != null)) ? annotationMemberArrayConditional_AST.getFirstChild() : annotationMemberArrayConditional_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    annotationMemberArrayConditional_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) annotationMemberArrayConditional_AST);
                }
                annotationMemberArrayConditional_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_27);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationMemberArrayConditional_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void superClassClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST superClassClause_AST = null;
            AST c_AST = null;
            try {
                switch (this.mLA1) {
                    case 71:
                        match(71);
                        classOrInterfaceType(false);
                        c_AST = this.returnAST;
                        break;
                    case 99:
                    case 106:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    superClassClause_AST = currentAST.root;
                    superClassClause_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(18, "EXTENDS_CLAUSE")).add(c_AST));
                    currentAST.root = superClassClause_AST;
                    currentAST.child = (((superClassClause_AST != null) && (superClassClause_AST.getFirstChild() != null)) ? superClassClause_AST.getFirstChild() : superClassClause_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_28);
                } else {
                    throw ex;
                }
            }
            this.returnAST = superClassClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeParameters() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeParameters_AST = null;
            int currentLtLevel = 0;
            Token firstToken = LT(1);
            try {
                if (this.inputState.guessing == 0) {
                    currentLtLevel = this.ltCounter;
                }
                match(73);
                if (this.inputState.guessing == 0) {
                    this.ltCounter += 1;
                }
                typeParameter();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 74) {
                    match(74);
                    typeParameter();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                switch (this.mLA1) {
                    case 75:
                    case 76:
                    case 77:
                        typeArgumentsOrParametersEnd();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 68:
                    case 71:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 99:
                    case 106:
                        break;
                    case 69:
                    case 70:
                    case 72:
                    case 73:
                    case 74:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 97:
                    case 98:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if ((currentLtLevel == 0) && (this.ltCounter != currentLtLevel)) {
                    throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
                }
                if (this.inputState.guessing == 0) {
                    typeParameters_AST = currentAST.root;
                    typeParameters_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(57, "TYPE_PARAMETERS")).add(typeParameters_AST));
                    setLineColumn(firstToken, (ASTImpl) typeParameters_AST);
                    currentAST.root = typeParameters_AST;
                    currentAST.child = (((typeParameters_AST != null) && (typeParameters_AST.getFirstChild() != null)) ? typeParameters_AST.getFirstChild() : typeParameters_AST);

                    currentAST.advanceChildToEnd();
                }
                typeParameters_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_29);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeParameters_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void implementsClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST implementsClause_AST = null;
            Token i = null;
            AST i_AST = null;
            try {
                boolean bLabel144 = false;
                switch (this.mLA1) {
                    case 106:
                        i = LT(1);
                        i_AST = this.astFactory.create(i);
                        match(106);
                        classOrInterfaceType(false);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        while (true) {
                            if (this.mLA1 != 74) {
//                                break label144;
                                bLabel144 = true;
                                break;
                            }
                            match(74);
                            classOrInterfaceType(false);
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }
                    case 99:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (bLabel144 || this.inputState.guessing == 0) {
                    label144:
                    implementsClause_AST = currentAST.root;
                    implementsClause_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(19, "IMPLEMENTS_CLAUSE")).add(implementsClause_AST));
                    currentAST.root = implementsClause_AST;
                    currentAST.child = (((implementsClause_AST != null) && (implementsClause_AST.getFirstChild() != null)) ? implementsClause_AST.getFirstChild() : implementsClause_AST);

                    currentAST.advanceChildToEnd();
                }
                implementsClause_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_30);
                } else {
                    throw ex;
                }
            }
            this.returnAST = implementsClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void classBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST classBlock_AST = null;
            Token firstToken = LT(1);
            try {
                match(99);
                boolean x = true;
                while (x) {
                    switch (this.mLA1) {
                        case 39:
                        case 40:
                        case 41:
                        case 65:
                        case 68:
                        case 73:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 99:
                        case 101:
                        case 102:
                        case 103:
                            classField();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            break;
                        case 63:
                            match(63);
                        case 42:
                        case 43:
                        case 44:
                        case 45:
                        case 46:
                        case 47:
                        case 48:
                        case 49:
                        case 50:
                        case 51:
                        case 52:
                        case 53:
                        case 54:
                        case 55:
                        case 56:
                        case 57:
                        case 58:
                        case 59:
                        case 60:
                        case 61:
                        case 62:
                        case 64:
                        case 66:
                        case 67:
                        case 69:
                        case 70:
                        case 71:
                        case 72:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 87:
                        case 96:
                        case 97:
                        case 98:
                        case 100:
                    }
                }
                match(100);
                if (this.inputState.guessing == 0) {
                    classBlock_AST = currentAST.root;

                    AST objBlock = this.astFactory.create(6, "OBJBLOCK");
                    classBlock_AST = this.astFactory.make(new ASTArray(2).add(objBlock).add(classBlock_AST));
                    setLineColumn(firstToken, (ASTImpl) objBlock);

                    currentAST.root = classBlock_AST;
                    currentAST.child = (((classBlock_AST != null) && (classBlock_AST.getFirstChild() != null)) ? classBlock_AST.getFirstChild() : classBlock_AST);

                    currentAST.advanceChildToEnd();
                }
                classBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_31);
                } else {
                    throw ex;
                }
            }
            this.returnAST = classBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void interfaceExtends() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST interfaceExtends_AST = null;
            Token e = null;
            AST e_AST = null;
            try {
                boolean bLabel144 = false;
                switch (this.mLA1) {
                    case 71:
                        e = LT(1);
                        e_AST = this.astFactory.create(e);
                        match(71);
                        classOrInterfaceType(false);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        boolean x = true;
                        while (x) {
                            if (this.mLA1 != 74) {
//                                break label144;
                                bLabel144 = true;
                                break;
                            }
                            match(74);
                            classOrInterfaceType(false);
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }
                    case 99:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (bLabel144 || this.inputState.guessing == 0) {
                    label144:
                    interfaceExtends_AST = currentAST.root;
                    interfaceExtends_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(18, "EXTENDS_CLAUSE")).add(interfaceExtends_AST));
                    currentAST.root = interfaceExtends_AST;
                    currentAST.child = (((interfaceExtends_AST != null) && (interfaceExtends_AST.getFirstChild() != null)) ? interfaceExtends_AST.getFirstChild() : interfaceExtends_AST);

                    currentAST.advanceChildToEnd();
                }
                interfaceExtends_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_30);
                } else {
                    throw ex;
                }
            }
            this.returnAST = interfaceExtends_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void interfaceBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST interfaceBlock_AST = null;
            Token firstToken = LT(1);
            try {
                match(99);
                boolean x = true;
                while (x) {
                    switch (this.mLA1) {
                        case 39:
                        case 40:
                        case 41:
                        case 65:
                        case 68:
                        case 73:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 101:
                        case 102:
                        case 103:
                            interfaceField();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            break;
                        case 63:
                            match(63);
                        case 42:
                        case 43:
                        case 44:
                        case 45:
                        case 46:
                        case 47:
                        case 48:
                        case 49:
                        case 50:
                        case 51:
                        case 52:
                        case 53:
                        case 54:
                        case 55:
                        case 56:
                        case 57:
                        case 58:
                        case 59:
                        case 60:
                        case 61:
                        case 62:
                        case 64:
                        case 66:
                        case 67:
                        case 69:
                        case 70:
                        case 71:
                        case 72:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 87:
                        case 96:
                        case 97:
                        case 98:
                        case 99:
                        case 100:
                    }
                }
                match(100);
                if (this.inputState.guessing == 0) {
                    interfaceBlock_AST = currentAST.root;

                    AST objBlock = this.astFactory.create(6, "OBJBLOCK");
                    interfaceBlock_AST = this.astFactory.make(new ASTArray(2).add(objBlock).add(interfaceBlock_AST));
                    setLineColumn(firstToken, (ASTImpl) objBlock);

                    currentAST.root = interfaceBlock_AST;
                    currentAST.child = (((interfaceBlock_AST != null) && (interfaceBlock_AST.getFirstChild() != null)) ? interfaceBlock_AST.getFirstChild() : interfaceBlock_AST);

                    currentAST.advanceChildToEnd();
                }
                interfaceBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = interfaceBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void enumBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST enumBlock_AST = null;
            Token firstToken = LT(1);
            try {
                match(99);

                switch (this.mLA1) {
                    case 68:
                    case 95:
                        enumConstant();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        while ((this.mLA1 == 74) && (((LA(2) == 68) || (LA(2) == 95)))) {
                            match(74);
                            enumConstant();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }

                        switch (this.mLA1) {
                            case 74:
                                match(74);
                                break;
                            case 63:
                            case 100:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 63:
                    case 100:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                switch (this.mLA1) {
                    case 63:
                        match(63);
                        boolean x = true;
                        while (x) {
                            switch (this.mLA1) {
                                case 39:
                                case 40:
                                case 41:
                                case 65:
                                case 68:
                                case 73:
                                case 78:
                                case 79:
                                case 80:
                                case 81:
                                case 82:
                                case 83:
                                case 84:
                                case 85:
                                case 86:
                                case 88:
                                case 89:
                                case 90:
                                case 91:
                                case 92:
                                case 93:
                                case 94:
                                case 95:
                                case 99:
                                case 101:
                                case 102:
                                case 103:
                                    classField();
                                    this.astFactory.addASTChild(currentAST, this.returnAST);
                                    break;
                                case 63:
                                    match(63);
                                case 42:
                                case 43:
                                case 44:
                                case 45:
                                case 46:
                                case 47:
                                case 48:
                                case 49:
                                case 50:
                                case 51:
                                case 52:
                                case 53:
                                case 54:
                                case 55:
                                case 56:
                                case 57:
                                case 58:
                                case 59:
                                case 60:
                                case 61:
                                case 62:
                                case 64:
                                case 66:
                                case 67:
                                case 69:
                                case 70:
                                case 71:
                                case 72:
                                case 74:
                                case 75:
                                case 76:
                                case 77:
                                case 87:
                                case 96:
                                case 97:
                                case 98:
                                case 100:
                            }
                        }
                        break;
                    case 100:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                match(100);
                if (this.inputState.guessing == 0) {
                    enumBlock_AST = currentAST.root;
                    AST objBlock_AST = this.astFactory.create(6, "OBJBLOCK");
                    enumBlock_AST = this.astFactory.make(new ASTArray(2).add(objBlock_AST).add(enumBlock_AST));
                    setLineColumn(firstToken, (ASTImpl) objBlock_AST);
                    currentAST.root = enumBlock_AST;
                    currentAST.child = (((enumBlock_AST != null) && (enumBlock_AST.getFirstChild() != null)) ? enumBlock_AST.getFirstChild() : enumBlock_AST);

                    currentAST.advanceChildToEnd();
                }
                enumBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = enumBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationBlock_AST = null;
            Token firstToken = LT(1);
            try {
                match(99);
                boolean x = true;
                while (x) {
                    switch (this.mLA1) {
                        case 39:
                        case 40:
                        case 41:
                        case 65:
                        case 68:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 101:
                        case 102:
                        case 103:
                            annotationField();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            break;
                        case 63:
                            match(63);
                        case 42:
                        case 43:
                        case 44:
                        case 45:
                        case 46:
                        case 47:
                        case 48:
                        case 49:
                        case 50:
                        case 51:
                        case 52:
                        case 53:
                        case 54:
                        case 55:
                        case 56:
                        case 57:
                        case 58:
                        case 59:
                        case 60:
                        case 61:
                        case 62:
                        case 64:
                        case 66:
                        case 67:
                        case 69:
                        case 70:
                        case 71:
                        case 72:
                        case 73:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 87:
                        case 96:
                        case 97:
                        case 98:
                        case 99:
                        case 100:
                    }
                }
                match(100);
                if (this.inputState.guessing == 0) {
                    annotationBlock_AST = currentAST.root;

                    AST objBlock_AST = this.astFactory.create(6, "OBJBLOCK");
                    annotationBlock_AST = this.astFactory.make(new ASTArray(2).add(objBlock_AST).add(annotationBlock_AST));
                    setLineColumn(firstToken, (ASTImpl) objBlock_AST);

                    currentAST.root = annotationBlock_AST;
                    currentAST.child = (((annotationBlock_AST != null) && (annotationBlock_AST.getFirstChild() != null)) ? annotationBlock_AST.getFirstChild() : annotationBlock_AST);

                    currentAST.advanceChildToEnd();
                }
                annotationBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_10);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeParameter() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeParameter_AST = null;
            Token id = null;
            AST id_AST = null;
            Token firstToken = LT(1);
            try {
                id = LT(1);
                id_AST = this.astFactory.create(id);
                this.astFactory.addASTChild(currentAST, id_AST);
                match(68);

                if ((this.mLA1 == 71) && (LA(2) == 68)) {
                    typeParameterBounds();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((!_tokenSet_32.member(this.mLA1)) || (!_tokenSet_33.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    typeParameter_AST = currentAST.root;
                    typeParameter_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(58, "TYPE_PARAMETER")).add(typeParameter_AST));
                    setLineColumn(firstToken, (ASTImpl) typeParameter_AST);
                    currentAST.root = typeParameter_AST;
                    currentAST.child = (((typeParameter_AST != null) && (typeParameter_AST.getFirstChild() != null)) ? typeParameter_AST.getFirstChild() : typeParameter_AST);

                    currentAST.advanceChildToEnd();
                }
                typeParameter_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_32);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeParameter_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST typeParameterBounds_AST = null;
            try {
                match(71);
                classOrInterfaceType(false);
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 104) {
                    match(104);
                    classOrInterfaceType(false);
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    typeParameterBounds_AST = currentAST.root;
                    typeParameterBounds_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(60, "TYPE_UPPER_BOUNDS")).add(typeParameterBounds_AST));
                    currentAST.root = typeParameterBounds_AST;
                    currentAST.child = (((typeParameterBounds_AST != null) && (typeParameterBounds_AST.getFirstChild() != null)) ? typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST);

                    currentAST.advanceChildToEnd();
                }
                typeParameterBounds_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_32);
                } else {
                    throw ex;
                }
            }
            this.returnAST = typeParameterBounds_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void classField() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST classField_AST = null;
            AST mods_AST = null;
            AST td_AST = null;
            AST tp_AST = null;
            AST h_AST = null;
            AST s_AST = null;
            AST t_AST = null;
            AST param_AST = null;
            AST rt_AST = null;
            AST tc_AST = null;
            AST s2_AST = null;
            AST v_AST = null;
            AST s3_AST = null;
            AST s4_AST = null;
            Token firstToken = LT(1);
            try {
                if ((_tokenSet_18.member(this.mLA1)) && (_tokenSet_34.member(LA(2)))) {
                    modifiers();
                    mods_AST = this.returnAST;
                }
                boolean bLabel144 = false;
                switch (this.mLA1) {
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                        typeDefinitionInternal(mods_AST, firstToken);
                        td_AST = this.returnAST;
                        if (this.inputState.guessing == 0) {
                            classField_AST = currentAST.root;
                            classField_AST = td_AST;
                            currentAST.root = classField_AST;
                            currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                            currentAST.advanceChildToEnd();
                        }
                        break;
                    case 68:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        switch (this.mLA1) {
                            case 73:
                                typeParameters();
                                tp_AST = this.returnAST;
                                break;
                            case 68:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                                break;
                            case 69:
                            case 70:
                            case 71:
                            case 72:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        if ((this.mLA1 == 68) && (LA(2) == 96)) {
                            ctorHead();
                            h_AST = this.returnAST;
                            constructorBody();
                            s_AST = this.returnAST;
                            if (this.inputState.guessing == 0) {
                                classField_AST = currentAST.root;
                                classField_AST = this.astFactory.make(new ASTArray(5).add(this.astFactory.create(8, "CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST));
                                currentAST.root = classField_AST;
                                currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else {
                            if ((_tokenSet_35.member(this.mLA1)) && (_tokenSet_36.member(LA(2)))) {
                                typeSpec(false);
                                t_AST = this.returnAST;

                                if ((this.mLA1 == 68) && (LA(2) == 96)) {
                                    AST tmp89_AST = null;
                                    tmp89_AST = this.astFactory.create(LT(1));
                                    match(68);
                                    match(96);
                                    parameterDeclarationList();
                                    param_AST = this.returnAST;
                                    match(97);
                                    declaratorBrackets(t_AST);
                                    rt_AST = this.returnAST;

                                    switch (this.mLA1) {
                                        case 108:
                                            throwsClause();
                                            tc_AST = this.returnAST;
                                            break;
                                        case 63:
                                        case 99:
                                            break;
                                        default:
                                            throw new NoViableAltException(LT(1), getFilename());
                                    }

                                    switch (this.mLA1) {
                                        case 99:
                                            compoundStatement();
                                            s2_AST = this.returnAST;
                                            break;
                                        case 63:
                                            AST tmp92_AST = null;
                                            tmp92_AST = this.astFactory.create(LT(1));
                                            match(63);
                                            break;
                                        default:
                                            throw new NoViableAltException(LT(1), getFilename());
                                    }

                                    if (this.inputState.guessing == 0) {
                                        classField_AST = currentAST.root;
                                        classField_AST = this.astFactory.make(new ASTArray(8).add(this.astFactory.create(9, "METHOD_DEF")).add(mods_AST).add(tp_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(rt_AST))).add(tmp89_AST).add(param_AST).add(tc_AST).add(s2_AST));
                                        currentAST.root = classField_AST;
                                        currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                                        currentAST.advanceChildToEnd();
                                    }
//                                    break label1441
                                    bLabel144 = true;
                                    break;
//
//                                  :
                                }
                                if ((this.mLA1 == 68) && (_tokenSet_37.member(LA(2)))) {
                                    variableDefinitions(mods_AST, t_AST);
                                    v_AST = this.returnAST;
                                    AST tmp93_AST = null;
                                    tmp93_AST = this.astFactory.create(LT(1));
                                    match(63);
                                    if (this.inputState.guessing == 0) {
                                        classField_AST = currentAST.root;
                                        classField_AST = v_AST;
                                        currentAST.root = classField_AST;
                                        currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                                        currentAST.advanceChildToEnd();
                                    }
//                                    break label1441
                                    bLabel144 = true;
                                    break;
//                                            :
                                }
                                throw new NoViableAltException(LT(1), getFilename());
                            }

                            throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    default:
//                        throw new NoViableAltException(LT(1), getFilename());

                        if ((this.mLA1 == 65) && (LA(2) == 99)) {
                            match(65);
                            compoundStatement();
                            s3_AST = this.returnAST;
                            if (this.inputState.guessing == 0) {
                                classField_AST = currentAST.root;
                                classField_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(12, "STATIC_INIT")).add(s3_AST));
                                currentAST.root = classField_AST;
                                currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else if (this.mLA1 == 99) {
                            compoundStatement();
                            s4_AST = this.returnAST;
                            if (this.inputState.guessing == 0) {
                                classField_AST = currentAST.root;
                                classField_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(11, "INSTANCE_INIT")).add(s4_AST));
                                currentAST.root = classField_AST;
                                currentAST.child = (((classField_AST != null) && (classField_AST.getFirstChild() != null)) ? classField_AST.getFirstChild() : classField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                }

                if (bLabel144 || this.inputState.guessing == 0) {
                    label1441:
                    classField_AST = currentAST.root;
                    setLineColumnAll(firstToken, (ASTImpl) classField_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_38);
                } else {
                    throw ex;
                }
            }
            this.returnAST = classField_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void interfaceField() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST interfaceField_AST = null;
            AST mods_AST = null;
            AST td_AST = null;
            AST tp_AST = null;
            AST t_AST = null;
            AST param_AST = null;
            AST rt_AST = null;
            AST tc_AST = null;
            AST v_AST = null;
            Token firstToken = LT(1);
            try {
                modifiers();
                mods_AST = this.returnAST;

                switch (this.mLA1) {
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                        typeDefinitionInternal(mods_AST, firstToken);
                        td_AST = this.returnAST;
                        if (this.inputState.guessing == 0) {
                            interfaceField_AST = currentAST.root;
                            interfaceField_AST = td_AST;
                            currentAST.root = interfaceField_AST;
                            currentAST.child = (((interfaceField_AST != null) && (interfaceField_AST.getFirstChild() != null)) ? interfaceField_AST.getFirstChild() : interfaceField_AST);

                            currentAST.advanceChildToEnd();
                        }
                        break;
                    case 68:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        switch (this.mLA1) {
                            case 73:
                                typeParameters();
                                tp_AST = this.returnAST;
                                break;
                            case 68:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                                break;
                            case 69:
                            case 70:
                            case 71:
                            case 72:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        typeSpec(false);
                        t_AST = this.returnAST;

                        if ((this.mLA1 == 68) && (LA(2) == 96)) {
                            AST tmp95_AST = null;
                            tmp95_AST = this.astFactory.create(LT(1));
                            match(68);
                            match(96);
                            parameterDeclarationList();
                            param_AST = this.returnAST;
                            match(97);
                            declaratorBrackets(t_AST);
                            rt_AST = this.returnAST;

                            switch (this.mLA1) {
                                case 108:
                                    throwsClause();
                                    tc_AST = this.returnAST;
                                    break;
                                case 63:
                                    break;
                                default:
                                    throw new NoViableAltException(LT(1), getFilename());
                            }

                            AST tmp98_AST = null;
                            tmp98_AST = this.astFactory.create(LT(1));
                            match(63);
                            if (this.inputState.guessing == 0) {
                                interfaceField_AST = currentAST.root;
                                interfaceField_AST = this.astFactory.make(new ASTArray(7).add(this.astFactory.create(9, "METHOD_DEF")).add(mods_AST).add(tp_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(rt_AST))).add(tmp95_AST).add(param_AST).add(tc_AST));
                                currentAST.root = interfaceField_AST;
                                currentAST.child = (((interfaceField_AST != null) && (interfaceField_AST.getFirstChild() != null)) ? interfaceField_AST.getFirstChild() : interfaceField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else if ((this.mLA1 == 68) && (_tokenSet_37.member(LA(2)))) {
                            variableDefinitions(mods_AST, t_AST);
                            v_AST = this.returnAST;
                            AST tmp99_AST = null;
                            tmp99_AST = this.astFactory.create(LT(1));
                            match(63);
                            if (this.inputState.guessing == 0) {
                                interfaceField_AST = currentAST.root;
                                interfaceField_AST = v_AST;
                                currentAST.root = interfaceField_AST;
                                currentAST.child = (((interfaceField_AST != null) && (interfaceField_AST.getFirstChild() != null)) ? interfaceField_AST.getFirstChild() : interfaceField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    interfaceField_AST = currentAST.root;
                    setLineColumnAll(firstToken, (ASTImpl) interfaceField_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_39);
                } else {
                    throw ex;
                }
            }
            this.returnAST = interfaceField_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationField() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationField_AST = null;
            AST mods_AST = null;
            AST td_AST = null;
            AST t_AST = null;
            Token i = null;
            AST i_AST = null;
            AST rt_AST = null;
            AST afd_AST = null;
            AST v_AST = null;
            Token firstToken = LT(1);
            try {
                modifiers();
                mods_AST = this.returnAST;

                switch (this.mLA1) {
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                        typeDefinitionInternal(mods_AST, firstToken);
                        td_AST = this.returnAST;
                        if (this.inputState.guessing == 0) {
                            annotationField_AST = currentAST.root;
                            annotationField_AST = td_AST;
                            currentAST.root = annotationField_AST;
                            currentAST.child = (((annotationField_AST != null) && (annotationField_AST.getFirstChild() != null)) ? annotationField_AST.getFirstChild() : annotationField_AST);

                            currentAST.advanceChildToEnd();
                        }
                        break;
                    case 68:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        typeSpec(false);
                        t_AST = this.returnAST;

                        if ((this.mLA1 == 68) && (LA(2) == 96)) {
                            i = LT(1);
                            i_AST = this.astFactory.create(i);
                            match(68);
                            match(96);
                            match(97);
                            declaratorBrackets(t_AST);
                            rt_AST = this.returnAST;
                            annotationFieldDefault();
                            afd_AST = this.returnAST;
                            AST tmp102_AST = null;
                            tmp102_AST = this.astFactory.create(LT(1));
                            match(63);
                            if (this.inputState.guessing == 0) {
                                annotationField_AST = currentAST.root;
                                annotationField_AST = this.astFactory.make(new ASTArray(5).add(this.astFactory.create(53, "ANNOTATION_FIELD_DEF")).add(mods_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(rt_AST))).add(i_AST).add(afd_AST));

                                currentAST.root = annotationField_AST;
                                currentAST.child = (((annotationField_AST != null) && (annotationField_AST.getFirstChild() != null)) ? annotationField_AST.getFirstChild() : annotationField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else if ((this.mLA1 == 68) && (_tokenSet_37.member(LA(2)))) {
                            variableDefinitions(mods_AST, t_AST);
                            v_AST = this.returnAST;
                            AST tmp103_AST = null;
                            tmp103_AST = this.astFactory.create(LT(1));
                            match(63);
                            if (this.inputState.guessing == 0) {
                                annotationField_AST = currentAST.root;
                                annotationField_AST = v_AST;
                                currentAST.root = annotationField_AST;
                                currentAST.child = (((annotationField_AST != null) && (annotationField_AST.getFirstChild() != null)) ? annotationField_AST.getFirstChild() : annotationField_AST);

                                currentAST.advanceChildToEnd();
                            }
                        } else {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 96:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    annotationField_AST = currentAST.root;
                    setLineColumnAll(firstToken, (ASTImpl) annotationField_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_40);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationField_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void enumConstant() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST enumConstant_AST = null;
            AST an_AST = null;
            Token i = null;
            AST i_AST = null;
            AST a_AST = null;
            AST b_AST = null;
            Token firstToken = LT(1);
            try {
                annotations();
                an_AST = this.returnAST;
                i = LT(1);
                i_AST = this.astFactory.create(i);
                match(68);

                switch (this.mLA1) {
                    case 96:
                        match(96);
                        argList();
                        a_AST = this.returnAST;
                        match(97);
                        break;
                    case 63:
                    case 74:
                    case 99:
                    case 100:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                switch (this.mLA1) {
                    case 99:
                        enumConstantBlock();
                        b_AST = this.returnAST;
                        break;
                    case 63:
                    case 74:
                    case 100:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    enumConstant_AST = currentAST.root;
                    enumConstant_AST = this.astFactory.make(new ASTArray(5).add(this.astFactory.create(47, "ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(a_AST).add(b_AST));
                    setLineColumn(firstToken, (ASTImpl) enumConstant_AST);
                    currentAST.root = enumConstant_AST;
                    currentAST.child = (((enumConstant_AST != null) && (enumConstant_AST.getFirstChild() != null)) ? enumConstant_AST.getFirstChild() : enumConstant_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_41);
                } else {
                    throw ex;
                }
            }
            this.returnAST = enumConstant_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void declaratorBrackets(AST typ) throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST declaratorBrackets_AST = null;
            Token lb = null;
            AST lb_AST = null;
            try {
                if (this.inputState.guessing == 0) {
                    declaratorBrackets_AST = currentAST.root;
                    declaratorBrackets_AST = typ;
                    currentAST.root = declaratorBrackets_AST;
                    currentAST.child = (((declaratorBrackets_AST != null) && (declaratorBrackets_AST.getFirstChild() != null)) ? declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST);

                    currentAST.advanceChildToEnd();
                }

                while (this.mLA1 == 66) {
                    lb = LT(1);
                    lb_AST = this.astFactory.create(lb);
                    this.astFactory.makeASTRoot(currentAST, lb_AST);
                    match(66);
                    if (this.inputState.guessing == 0) {
                        lb_AST.setType(17);
                    }
                    match(67);
                }

                declaratorBrackets_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_42);
                } else {
                    throw ex;
                }
            }
            this.returnAST = declaratorBrackets_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void annotationFieldDefault() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST annotationFieldDefault_AST = null;
            Token assign = null;
            AST assign_AST = null;
            try {
                switch (this.mLA1) {
                    case 105:
                        assign = LT(1);
                        assign_AST = this.astFactory.create(assign);
                        this.astFactory.makeASTRoot(currentAST, assign_AST);
                        match(105);
                        if (this.inputState.guessing == 0) {
                            assign_AST.setType(98);
                        }
                        annotationMemberValueInitializer();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                annotationFieldDefault_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = annotationFieldDefault_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void argList() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST argList_AST = null;
            TokenExt firstToken = (TokenExt) LT(1);
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        expressionList();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 97:
                        if (this.inputState.guessing == 0) {
                            argList_AST = currentAST.root;
                            argList_AST = this.astFactory.create(34, "ELIST");
                            currentAST.root = argList_AST;
                            currentAST.child = (((argList_AST != null) && (argList_AST.getFirstChild() != null)) ? argList_AST.getFirstChild() : argList_AST);

                            currentAST.advanceChildToEnd();
                        }
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    argList_AST = currentAST.root;

                    ASTImpl typeAst = (ASTImpl) argList_AST;
                    typeAst.setColumn(firstToken.getColumn());
                    typeAst.setLine(firstToken.getLine());
                    TokenExt rparenToken = (TokenExt) LT(1);
                    typeAst.setEndLine(rparenToken.getEndLine());
                    typeAst.setEndColumn(rparenToken.getEndColumn());
                }

                argList_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = argList_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST enumConstantBlock_AST = null;
            Token firstToken = LT(1);
            try {
                match(99);
                boolean x = true;
                while (x) {
                    switch (this.mLA1) {
                        case 39:
                        case 40:
                        case 41:
                        case 65:
                        case 68:
                        case 73:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 99:
                        case 101:
                        case 102:
                        case 103:
                            enumConstantField();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            break;
                        case 63:
                            match(63);
                        case 42:
                        case 43:
                        case 44:
                        case 45:
                        case 46:
                        case 47:
                        case 48:
                        case 49:
                        case 50:
                        case 51:
                        case 52:
                        case 53:
                        case 54:
                        case 55:
                        case 56:
                        case 57:
                        case 58:
                        case 59:
                        case 60:
                        case 61:
                        case 62:
                        case 64:
                        case 66:
                        case 67:
                        case 69:
                        case 70:
                        case 71:
                        case 72:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 87:
                        case 96:
                        case 97:
                        case 98:
                        case 100:
                    }
                }
                match(100);
                if (this.inputState.guessing == 0) {
                    enumConstantBlock_AST = currentAST.root;
                    AST objBlock = this.astFactory.create(6, "OBJBLOCK");
                    enumConstantBlock_AST = this.astFactory.make(new ASTArray(2).add(objBlock).add(enumConstantBlock_AST));
                    setLineColumn(firstToken, (ASTImpl) objBlock);
                    currentAST.root = enumConstantBlock_AST;
                    currentAST.child = (((enumConstantBlock_AST != null) && (enumConstantBlock_AST.getFirstChild() != null)) ? enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST);

                    currentAST.advanceChildToEnd();
                }
                enumConstantBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_41);
                } else {
                    throw ex;
                }
            }
            this.returnAST = enumConstantBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void enumConstantField() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST enumConstantField_AST = null;
            AST mods_AST = null;
            AST td_AST = null;
            AST tp_AST = null;
            AST t_AST = null;
            AST param_AST = null;
            AST rt_AST = null;
            AST tc_AST = null;
            AST s2_AST = null;
            AST v_AST = null;
            AST s4_AST = null;
            Token firstToken = LT(1);
            try {
                switch (this.mLA1) {
                    case 39:
                    case 40:
                    case 41:
                    case 65:
                    case 68:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 101:
                    case 102:
                    case 103:
                        modifiers();
                        mods_AST = this.returnAST;

                        switch (this.mLA1) {
                            case 95:
                            case 101:
                            case 102:
                            case 103:
                                typeDefinitionInternal(mods_AST, firstToken);
                                td_AST = this.returnAST;
                                if (this.inputState.guessing == 0) {
                                    enumConstantField_AST = currentAST.root;
                                    enumConstantField_AST = td_AST;
                                    currentAST.root = enumConstantField_AST;
                                    currentAST.child = (((enumConstantField_AST != null) && (enumConstantField_AST.getFirstChild() != null)) ? enumConstantField_AST.getFirstChild() : enumConstantField_AST);

                                    currentAST.advanceChildToEnd();
                                }
                                break;
                            case 68:
                            case 73:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                                switch (this.mLA1) {
                                    case 73:
                                        typeParameters();
                                        tp_AST = this.returnAST;
                                        break;
                                    case 68:
                                    case 78:
                                    case 79:
                                    case 80:
                                    case 81:
                                    case 82:
                                    case 83:
                                    case 84:
                                    case 85:
                                    case 86:
                                        break;
                                    case 69:
                                    case 70:
                                    case 71:
                                    case 72:
                                    case 74:
                                    case 75:
                                    case 76:
                                    case 77:
                                    default:
                                        throw new NoViableAltException(LT(1), getFilename());
                                }

                                typeSpec(false);
                                t_AST = this.returnAST;

                                if ((this.mLA1 == 68) && (LA(2) == 96)) {
                                    AST tmp110_AST = null;
                                    tmp110_AST = this.astFactory.create(LT(1));
                                    match(68);
                                    match(96);
                                    parameterDeclarationList();
                                    param_AST = this.returnAST;
                                    match(97);
                                    declaratorBrackets(t_AST);
                                    rt_AST = this.returnAST;

                                    switch (this.mLA1) {
                                        case 108:
                                            throwsClause();
                                            tc_AST = this.returnAST;
                                            break;
                                        case 63:
                                        case 99:
                                            break;
                                        default:
                                            throw new NoViableAltException(LT(1), getFilename());
                                    }

                                    switch (this.mLA1) {
                                        case 99:
                                            compoundStatement();
                                            s2_AST = this.returnAST;
                                            break;
                                        case 63:
                                            AST tmp113_AST = null;
                                            tmp113_AST = this.astFactory.create(LT(1));
                                            match(63);
                                            break;
                                        default:
                                            throw new NoViableAltException(LT(1), getFilename());
                                    }

                                    if (this.inputState.guessing == 0) {
                                        enumConstantField_AST = currentAST.root;
                                        enumConstantField_AST = this.astFactory.make(new ASTArray(8).add(this.astFactory.create(9, "METHOD_DEF")).add(mods_AST).add(tp_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(rt_AST))).add(tmp110_AST).add(param_AST).add(tc_AST).add(s2_AST));
                                        currentAST.root = enumConstantField_AST;
                                        currentAST.child = (((enumConstantField_AST != null) && (enumConstantField_AST.getFirstChild() != null)) ? enumConstantField_AST.getFirstChild() : enumConstantField_AST);

                                        currentAST.advanceChildToEnd();
                                    }
                                } else if ((this.mLA1 == 68) && (_tokenSet_37.member(LA(2)))) {
                                    variableDefinitions(mods_AST, t_AST);
                                    v_AST = this.returnAST;
                                    AST tmp114_AST = null;
                                    tmp114_AST = this.astFactory.create(LT(1));
                                    match(63);
                                    if (this.inputState.guessing == 0) {
                                        enumConstantField_AST = currentAST.root;
                                        enumConstantField_AST = v_AST;
                                        currentAST.root = enumConstantField_AST;
                                        currentAST.child = (((enumConstantField_AST != null) && (enumConstantField_AST.getFirstChild() != null)) ? enumConstantField_AST.getFirstChild() : enumConstantField_AST);

                                        currentAST.advanceChildToEnd();
                                    }
                                } else {
                                    throw new NoViableAltException(LT(1), getFilename());
                                }
                            case 69:
                            case 70:
                            case 71:
                            case 72:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 96:
                            case 97:
                            case 98:
                            case 99:
                            case 100:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 99:
                        compoundStatement();
                        s4_AST = this.returnAST;
                        if (this.inputState.guessing == 0) {
                            enumConstantField_AST = currentAST.root;
                            enumConstantField_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(11, "INSTANCE_INIT")).add(s4_AST));
                            currentAST.root = enumConstantField_AST;
                            currentAST.child = (((enumConstantField_AST != null) && (enumConstantField_AST.getFirstChild() != null)) ? enumConstantField_AST.getFirstChild() : enumConstantField_AST);

                            currentAST.advanceChildToEnd();
                        }
                        break;
                    case 42:
                    case 43:
                    case 44:
                    case 45:
                    case 46:
                    case 47:
                    case 48:
                    case 49:
                    case 50:
                    case 51:
                    case 52:
                    case 53:
                    case 54:
                    case 55:
                    case 56:
                    case 57:
                    case 58:
                    case 59:
                    case 60:
                    case 61:
                    case 62:
                    case 63:
                    case 64:
                    case 66:
                    case 67:
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 96:
                    case 97:
                    case 98:
                    case 100:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    enumConstantField_AST = currentAST.root;
                    setLineColumnAll(firstToken, (ASTImpl) enumConstantField_AST);
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_38);
                } else {
                    throw ex;
                }
            }
            this.returnAST = enumConstantField_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST parameterDeclarationList_AST = null;
            Token firstToken = LT(0);
            try {
                boolean synPredMatched192 = false;
                if ((_tokenSet_43.member(this.mLA1)) && (_tokenSet_44.member(LA(2)))) {
                    int _m192 = mark();
                    synPredMatched192 = true;
                    this.inputState.guessing += 1;
                    try {
                        parameterDeclaration();
                    } catch (RecognitionException pe) {
                        synPredMatched192 = false;
                    }
                    rewind(_m192);
                    this.inputState.guessing -= 1;
                }
                if (synPredMatched192) {
                    parameterDeclaration();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                    boolean x = true;
                    while (x) {
                        boolean synPredMatched195 = false;
                        if ((this.mLA1 == 74) && (_tokenSet_43.member(LA(2)))) {
                            int _m195 = mark();
                            synPredMatched195 = true;
                            this.inputState.guessing += 1;
                            try {
                                match(74);
                                parameterDeclaration();
                            } catch (RecognitionException pe) {
                                synPredMatched195 = false;
                            }
                            rewind(_m195);
                            this.inputState.guessing -= 1;
                        }
                        if (!synPredMatched195) {
                            break;
                        }
                        match(74);
                        parameterDeclaration();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                    }

                }

                switch (this.mLA1) {
                    case 74:
                        match(74);
                        variableLengthParameterDeclaration();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 97:
                        break;
                    default:

                        if ((_tokenSet_43.member(this.mLA1)) && (_tokenSet_45.member(LA(2)))) {
                            variableLengthParameterDeclaration();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else if (this.mLA1 != 97) {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    parameterDeclarationList_AST = currentAST.root;
                    parameterDeclarationList_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(20, "PARAMETERS")).add(parameterDeclarationList_AST));
                    ASTImpl listAst = (ASTImpl) parameterDeclarationList_AST;
                    if (listAst != null) {
                        listAst.setColumn(((TokenExt) firstToken).getEndColumn());
                        listAst.setLine(((TokenExt) firstToken).getEndLine());
                        TokenExt lastToken = (TokenExt) LT(0);
                        listAst.setEndColumn(lastToken.getEndColumn());
                        listAst.setEndLine(lastToken.getEndLine());
                    }

                    currentAST.root = parameterDeclarationList_AST;
                    currentAST.child = (((parameterDeclarationList_AST != null) && (parameterDeclarationList_AST.getFirstChild() != null)) ? parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST);

                    currentAST.advanceChildToEnd();
                }
                parameterDeclarationList_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = parameterDeclarationList_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void throwsClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST throwsClause_AST = null;
            try {
                AST tmp117_AST = null;
                tmp117_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp117_AST);
                match(108);
                identifier();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 74) {
                    match(74);
                    identifier();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                throwsClause_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_46);
                } else {
                    throw ex;
                }
            }
            this.returnAST = throwsClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void compoundStatement() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST compoundStatement_AST = null;
            Token lc = null;
            AST lc_AST = null;
            Token firstToken = LT(1);
            try {
                lc = LT(1);
                lc_AST = this.astFactory.create(lc);
                this.astFactory.makeASTRoot(currentAST, lc_AST);
                match(99);
                if (this.inputState.guessing == 0) {
                    lc_AST.setType(7);
                }

                while (_tokenSet_47.member(this.mLA1)) {
                    statement();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                match(100);
                if (this.inputState.guessing == 0) {
                    compoundStatement_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) compoundStatement_AST);
                }
                compoundStatement_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_48);
                } else {
                    throw ex;
                }
            }
            this.returnAST = compoundStatement_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void ctorHead() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST ctorHead_AST = null;
            try {
                AST tmp120_AST = null;
                tmp120_AST = this.astFactory.create(LT(1));
                this.astFactory.addASTChild(currentAST, tmp120_AST);
                match(68);
                match(96);
                parameterDeclarationList();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(97);

                switch (this.mLA1) {
                    case 108:
                        throwsClause();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 99:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                ctorHead_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_30);
                } else {
                    throw ex;
                }
            }
            this.returnAST = ctorHead_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void constructorBody() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST constructorBody_AST = null;
            Token lc = null;
            AST lc_AST = null;
            Token firstToken = LT(1);
            try {
                lc = LT(1);
                lc_AST = this.astFactory.create(lc);
                this.astFactory.makeASTRoot(currentAST, lc_AST);
                match(99);
                if (this.inputState.guessing == 0) {
                    lc_AST.setType(7);
                }

                if ((_tokenSet_49.member(this.mLA1)) && (_tokenSet_50.member(LA(2)))) {
                    explicitConstructorInvocation();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((!_tokenSet_51.member(this.mLA1)) || (!_tokenSet_52.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                while (_tokenSet_47.member(this.mLA1)) {
                    statement();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                match(100);

                if (this.inputState.guessing == 0) {
                    constructorBody_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) constructorBody_AST);
                }
                constructorBody_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_38);
                } else {
                    throw ex;
                }
            }
            this.returnAST = constructorBody_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST explicitConstructorInvocation_AST = null;
            Token lp1 = null;
            AST lp1_AST = null;
            Token lp2 = null;
            AST lp2_AST = null;
            Token firstToken = LT(1);
            try {
                switch (this.mLA1) {
                    case 73:
                        typeArguments();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 72:
                    case 107:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                switch (this.mLA1) {
                    case 107:
                        AST tmp124_AST = null;
                        tmp124_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp124_AST);
                        match(107);
                        lp1 = LT(1);
                        lp1_AST = this.astFactory.create(lp1);
                        this.astFactory.makeASTRoot(currentAST, lp1_AST);
                        match(96);
                        argList();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        match(63);
                        if (this.inputState.guessing == 0) {
                            lp1_AST.setType(43);
                        }
                        break;
                    case 72:
                        AST tmp127_AST = null;
                        tmp127_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp127_AST);
                        match(72);
                        lp2 = LT(1);
                        lp2_AST = this.astFactory.create(lp2);
                        this.astFactory.makeASTRoot(currentAST, lp2_AST);
                        match(96);
                        argList();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        match(63);
                        if (this.inputState.guessing == 0) {
                            lp2_AST.setType(42);
                        }
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    explicitConstructorInvocation_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) explicitConstructorInvocation_AST);
                }
                explicitConstructorInvocation_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_51);
                } else {
                    throw ex;
                }
            }
            this.returnAST = explicitConstructorInvocation_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void statement() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST statement_AST = null;
            AST m_AST = null;
            Token c = null;
            AST c_AST = null;
            Token s = null;
            AST s_AST = null;
            Token firstToken = LT(1);
            try {
                switch (this.mLA1) {
                    case 99:
                        compoundStatement();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 111:
                        AST tmp130_AST = null;
                        tmp130_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp130_AST);
                        match(111);
                        match(96);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        statement();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        if ((this.mLA1 == 112) && (_tokenSet_47.member(LA(2)))) {
                            match(112);
                            statement();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else if ((!_tokenSet_53.member(this.mLA1)) || (!_tokenSet_54.member(LA(2)))) {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 121:
                        forStatement();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 113:
                        AST tmp134_AST = null;
                        tmp134_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp134_AST);
                        match(113);
                        match(96);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        statement();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 114:
                        AST tmp137_AST = null;
                        tmp137_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp137_AST);
                        match(114);
                        statement();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(113);
                        match(96);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        match(63);
                        break;
                    case 115:
                        AST tmp142_AST = null;
                        tmp142_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp142_AST);
                        match(115);

                        switch (this.mLA1) {
                            case 68:
                                AST tmp143_AST = null;
                                tmp143_AST = this.astFactory.create(LT(1));
                                this.astFactory.addASTChild(currentAST, tmp143_AST);
                                match(68);
                                break;
                            case 63:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(63);
                        break;
                    case 116:
                        AST tmp145_AST = null;
                        tmp145_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp145_AST);
                        match(116);

                        switch (this.mLA1) {
                            case 68:
                                AST tmp146_AST = null;
                                tmp146_AST = this.astFactory.create(LT(1));
                                this.astFactory.addASTChild(currentAST, tmp146_AST);
                                match(68);
                                break;
                            case 63:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(63);
                        break;
                    case 117:
                        AST tmp148_AST = null;
                        tmp148_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp148_AST);
                        match(117);

                        switch (this.mLA1) {
                            case 68:
                            case 72:
                            case 73:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 96:
                            case 107:
                            case 147:
                            case 148:
                            case 151:
                            case 152:
                            case 153:
                            case 154:
                            case 155:
                            case 156:
                            case 157:
                            case 158:
                            case 159:
                            case 160:
                            case 161:
                            case 162:
                            case 163:
                            case 164:
                                expression();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 63:
                                break;
                            case 64:
                            case 65:
                            case 66:
                            case 67:
                            case 69:
                            case 70:
                            case 71:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 95:
                            case 97:
                            case 98:
                            case 99:
                            case 100:
                            case 101:
                            case 102:
                            case 103:
                            case 104:
                            case 105:
                            case 106:
                            case 108:
                            case 109:
                            case 110:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 149:
                            case 150:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(63);
                        break;
                    case 118:
                        AST tmp150_AST = null;
                        tmp150_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp150_AST);
                        match(118);
                        match(96);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        match(99);

                        while ((this.mLA1 == 105) || (this.mLA1 == 122)) {
                            casesGroup();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }

                        match(100);
                        break;
                    case 123:
                        tryBlock();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 119:
                        AST tmp155_AST = null;
                        tmp155_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp155_AST);
                        match(119);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(63);
                        break;
                    case 120:
                        AST tmp157_AST = null;
                        tmp157_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp157_AST);
                        match(120);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        switch (this.mLA1) {
                            case 110:
                                match(110);
                                expression();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 63:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(63);
                        break;
                    case 63:
                        s = LT(1);
                        s_AST = this.astFactory.create(s);
                        this.astFactory.addASTChild(currentAST, s_AST);
                        match(63);
                        if (this.inputState.guessing == 0) {
                            s_AST.setType(38);
                        }
                        break;
                    default:
                        boolean synPredMatched212 = false;
                        if ((_tokenSet_55.member(this.mLA1)) && (_tokenSet_56.member(LA(2)))) {
                            int _m212 = mark();
                            synPredMatched212 = true;
                            this.inputState.guessing += 1;
                            try {
                                declaration();
                            } catch (RecognitionException pe) {
                                synPredMatched212 = false;
                            }
                            rewind(_m212);
                            this.inputState.guessing -= 1;
                        }
                        if (synPredMatched212) {
                            declaration();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            match(63);
                        } else if ((_tokenSet_57.member(this.mLA1)) && (_tokenSet_58.member(LA(2)))) {
                            expression();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            match(63);
                        } else if ((_tokenSet_59.member(this.mLA1)) && (_tokenSet_60.member(LA(2)))) {
                            modifiers();
                            m_AST = this.returnAST;
                            classDefinition(m_AST, firstToken);
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else if ((this.mLA1 == 68) && (LA(2) == 110)) {
                            AST tmp162_AST = null;
                            tmp162_AST = this.astFactory.create(LT(1));
                            this.astFactory.addASTChild(currentAST, tmp162_AST);
                            match(68);
                            c = LT(1);
                            c_AST = this.astFactory.create(c);
                            this.astFactory.makeASTRoot(currentAST, c_AST);
                            match(110);
                            if (this.inputState.guessing == 0) {
                                c_AST.setType(22);
                            }
                            statement();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else if ((this.mLA1 == 93) && (LA(2) == 96)) {
                            AST tmp163_AST = null;
                            tmp163_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp163_AST);
                            match(93);
                            match(96);
                            expression();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            match(97);
                            compoundStatement();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                }

                if (this.inputState.guessing == 0) {
                    statement_AST = currentAST.root;

                    if (statement_AST != null) {
                        ASTImpl statementAst = (ASTImpl) statement_AST;
                        if ((statementAst.getLine() == 0) || (statementAst.getType() == 22)) {
                            statementAst.setLine(firstToken.getLine());
                        }
                        if ((statementAst.getColumn() == 0) || (statementAst.getType() == 22)) {
                            statementAst.setColumn(firstToken.getColumn());
                        }
                        TokenExt lastToken = (TokenExt) LT(0);
                        statementAst.setEndLine(lastToken.getEndLine());
                        statementAst.setEndColumn(lastToken.getEndColumn());
                    }
                }

                statement_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_53);
                } else {
                    throw ex;
                }
            }
            this.returnAST = statement_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void variableDeclarator(AST mods, AST t)
            throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST variableDeclarator_AST = null;
            Token id = null;
            AST id_AST = null;
            AST d_AST = null;
            AST v_AST = null;
            try {
                id = LT(1);
                id_AST = this.astFactory.create(id);
                match(68);
                declaratorBrackets(t);
                d_AST = this.returnAST;
                varInitializer();
                v_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    variableDeclarator_AST = currentAST.root;
                    variableDeclarator_AST = this.astFactory.make(new ASTArray(5).add(this.astFactory.create(10, "VARIABLE_DEF")).add(mods).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(d_AST))).add(id_AST).add(v_AST));
                    currentAST.root = variableDeclarator_AST;
                    currentAST.child = (((variableDeclarator_AST != null) && (variableDeclarator_AST.getFirstChild() != null)) ? variableDeclarator_AST.getFirstChild() : variableDeclarator_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_61);
                } else {
                    throw ex;
                }
            }
            this.returnAST = variableDeclarator_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void varInitializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST varInitializer_AST = null;
            try {
                switch (this.mLA1) {
                    case 98:
                        AST tmp166_AST = null;
                        tmp166_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp166_AST);
                        match(98);
                        initializer();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                    case 74:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                varInitializer_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_61);
                } else {
                    throw ex;
                }
            }
            this.returnAST = varInitializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void initializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST initializer_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        initializer_AST = currentAST.root;
                        break;
                    case 99:
                        arrayInitializer();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        initializer_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 98:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_41);
                } else {
                    throw ex;
                }
            }
            this.returnAST = initializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void arrayInitializer() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST arrayInitializer_AST = null;
            Token lc = null;
            AST lc_AST = null;
            Token lc2 = null;
            AST lc2_AST = null;
            try {
                if ((this.mLA1 == 99) && (_tokenSet_62.member(LA(2)))) {
                    lc = LT(1);
                    lc_AST = this.astFactory.create(lc);
                    this.astFactory.makeASTRoot(currentAST, lc_AST);
                    match(99);
                    if (this.inputState.guessing == 0) {
                        lc_AST.setType(29);
                    }

                    switch (this.mLA1) {
                        case 68:
                        case 72:
                        case 73:
                        case 78:
                        case 79:
                        case 80:
                        case 81:
                        case 82:
                        case 83:
                        case 84:
                        case 85:
                        case 86:
                        case 96:
                        case 99:
                        case 107:
                        case 147:
                        case 148:
                        case 151:
                        case 152:
                        case 153:
                        case 154:
                        case 155:
                        case 156:
                        case 157:
                        case 158:
                        case 159:
                        case 160:
                        case 161:
                        case 162:
                        case 163:
                        case 164:
                            initializer();
                            this.astFactory.addASTChild(currentAST, this.returnAST);

                            while ((this.mLA1 == 74) && (_tokenSet_63.member(LA(2)))) {
                                match(74);
                                initializer();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                            }

                            switch (this.mLA1) {
                                case 74:
                                    match(74);
                                    break;
                                case 100:
                                    break;
                                default:
                                    throw new NoViableAltException(LT(1), getFilename());
                            }
                        case 100:
                            break;
                        case 69:
                        case 70:
                        case 71:
                        case 74:
                        case 75:
                        case 76:
                        case 77:
                        case 87:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 94:
                        case 95:
                        case 97:
                        case 98:
                        case 101:
                        case 102:
                        case 103:
                        case 104:
                        case 105:
                        case 106:
                        case 108:
                        case 109:
                        case 110:
                        case 111:
                        case 112:
                        case 113:
                        case 114:
                        case 115:
                        case 116:
                        case 117:
                        case 118:
                        case 119:
                        case 120:
                        case 121:
                        case 122:
                        case 123:
                        case 124:
                        case 125:
                        case 126:
                        case 127:
                        case 128:
                        case 129:
                        case 130:
                        case 131:
                        case 132:
                        case 133:
                        case 134:
                        case 135:
                        case 136:
                        case 137:
                        case 138:
                        case 139:
                        case 140:
                        case 141:
                        case 142:
                        case 143:
                        case 144:
                        case 145:
                        case 146:
                        case 149:
                        case 150:
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                    match(100);
                } else if ((this.mLA1 == 99) && (LA(2) == 74)) {
                    lc2 = LT(1);
                    lc2_AST = this.astFactory.create(lc2);
                    this.astFactory.makeASTRoot(currentAST, lc2_AST);
                    match(99);
                    if (this.inputState.guessing == 0) {
                        lc2_AST.setType(29);
                    }
                    match(74);
                    match(100);
                } else {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    arrayInitializer_AST = currentAST.root;
                    if (arrayInitializer_AST != null) {
                        ASTImpl bodyAst = (ASTImpl) arrayInitializer_AST;
                        TokenExt lastToken = (TokenExt) LT(0);
                        bodyAst.setEndLine(lastToken.getEndLine());
                        bodyAst.setEndColumn(lastToken.getEndColumn());
                    }
                }

                arrayInitializer_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_64);
                } else {
                    throw ex;
                }
            }
            this.returnAST = arrayInitializer_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void expression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST expression_AST = null;
            Token firstToken = LT(1);
            try {
                assignmentExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                if (this.inputState.guessing == 0) {
                    expression_AST = currentAST.root;
                    expression_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(28, "EXPR")).add(expression_AST));
                    currentAST.root = expression_AST;
                    currentAST.child = (((expression_AST != null) && (expression_AST.getFirstChild() != null)) ? expression_AST.getFirstChild() : expression_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    expression_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) expression_AST);
                }
                expression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_65);
                } else {
                    throw ex;
                }
            }
            this.returnAST = expression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST parameterDeclaration_AST = null;
            AST pm_AST = null;
            AST t_AST = null;
            Token id = null;
            AST id_AST = null;
            AST pd_AST = null;
            Token firstToken = LT(1);
            try {
                parameterModifier();
                pm_AST = this.returnAST;
                typeSpec(false);
                t_AST = this.returnAST;
                id = LT(1);
                id_AST = this.astFactory.create(id);
                match(68);
                declaratorBrackets(t_AST);
                pd_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    parameterDeclaration_AST = currentAST.root;
                    AST parameterDef = this.astFactory.create(21, "PARAMETER_DEF");
                    parameterDeclaration_AST = this.astFactory.make(new ASTArray(4).add(parameterDef).add(pm_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(pd_AST))).add(id_AST));
                    setLineColumn(firstToken, (ASTImpl) parameterDef);
                    currentAST.root = parameterDeclaration_AST;
                    currentAST.child = (((parameterDeclaration_AST != null) && (parameterDeclaration_AST.getFirstChild() != null)) ? parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_66);
                } else {
                    throw ex;
                }
            }
            this.returnAST = parameterDeclaration_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST variableLengthParameterDeclaration_AST = null;
            AST pm_AST = null;
            AST t_AST = null;
            Token id = null;
            AST id_AST = null;
            AST pd_AST = null;
            try {
                parameterModifier();
                pm_AST = this.returnAST;
                typeSpec(false);
                t_AST = this.returnAST;
                match(109);
                id = LT(1);
                id_AST = this.astFactory.create(id);
                match(68);
                declaratorBrackets(t_AST);
                pd_AST = this.returnAST;
                if (this.inputState.guessing == 0) {
                    variableLengthParameterDeclaration_AST = currentAST.root;
                    variableLengthParameterDeclaration_AST = this.astFactory.make(new ASTArray(4).add(this.astFactory.create(44, "VARIABLE_PARAMETER_DEF")).add(pm_AST).add(this.astFactory.make(new ASTArray(2).add(this.astFactory.create(13, "TYPE")).add(pd_AST))).add(id_AST));
                    currentAST.root = variableLengthParameterDeclaration_AST;
                    currentAST.child = (((variableLengthParameterDeclaration_AST != null) && (variableLengthParameterDeclaration_AST.getFirstChild() != null)) ? variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST);

                    currentAST.advanceChildToEnd();
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = variableLengthParameterDeclaration_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void parameterModifier() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST parameterModifier_AST = null;
            Token f = null;
            AST f_AST = null;
            try {
                while ((this.mLA1 == 95) && (LA(2) == 68)) {
                    annotation();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                switch (this.mLA1) {
                    case 39:
                        f = LT(1);
                        f_AST = this.astFactory.create(f);
                        this.astFactory.addASTChild(currentAST, f_AST);
                        match(39);
                        break;
                    case 68:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 95:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                while (this.mLA1 == 95) {
                    annotation();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    parameterModifier_AST = currentAST.root;
                    parameterModifier_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(5, "MODIFIERS")).add(parameterModifier_AST));
                    currentAST.root = parameterModifier_AST;
                    currentAST.child = (((parameterModifier_AST != null) && (parameterModifier_AST.getFirstChild() != null)) ? parameterModifier_AST.getFirstChild() : parameterModifier_AST);

                    currentAST.advanceChildToEnd();
                }
                parameterModifier_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_35);
                } else {
                    throw ex;
                }
            }
            this.returnAST = parameterModifier_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forStatement() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forStatement_AST = null;
            Token f = null;
            AST f_AST = null;
            try {
                f = LT(1);
                f_AST = this.astFactory.create(f);
                this.astFactory.makeASTRoot(currentAST, f_AST);
                match(121);
                match(96);

                boolean synPredMatched223 = false;
                if ((_tokenSet_67.member(this.mLA1)) && (_tokenSet_68.member(LA(2)))) {
                    int _m223 = mark();
                    synPredMatched223 = true;
                    this.inputState.guessing += 1;
                    try {
                        forInit();
                        match(63);
                    } catch (RecognitionException pe) {
                        synPredMatched223 = false;
                    }
                    rewind(_m223);
                    this.inputState.guessing -= 1;
                }
                if (synPredMatched223) {
                    traditionalForClause();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((_tokenSet_43.member(this.mLA1)) && (_tokenSet_44.member(LA(2)))) {
                    forEachClause();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                match(97);
                statement();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                forStatement_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_53);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forStatement_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void casesGroup() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST casesGroup_AST = null;
            try {
                int _cnt229 = 0;
                while (true) {
                    if ((((this.mLA1 == 105) || (this.mLA1 == 122))) && (_tokenSet_69.member(LA(2)))) {
                        aCase();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                    } else {
                        if (_cnt229 >= 1) {
                            break;
                        }
                        throw new NoViableAltException(LT(1), getFilename());
                    }

                    ++_cnt229;
                }

                caseSList();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                if (this.inputState.guessing == 0) {
                    casesGroup_AST = currentAST.root;
                    casesGroup_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(33, "CASE_GROUP")).add(casesGroup_AST));
                    currentAST.root = casesGroup_AST;
                    currentAST.child = (((casesGroup_AST != null) && (casesGroup_AST.getFirstChild() != null)) ? casesGroup_AST.getFirstChild() : casesGroup_AST);

                    currentAST.advanceChildToEnd();
                }
                casesGroup_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_70);
                } else {
                    throw ex;
                }
            }
            this.returnAST = casesGroup_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void tryBlock() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST tryBlock_AST = null;
            Token firstToken = LT(1);
            try {
                AST tmp175_AST = null;
                tmp175_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp175_AST);
                match(123);
                compoundStatement();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 125) {
                    handler();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                switch (this.mLA1) {
                    case 124:
                        finallyClause();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 39:
                    case 40:
                    case 41:
                    case 63:
                    case 65:
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 99:
                    case 100:
                    case 101:
                    case 105:
                    case 107:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        break;
                    case 42:
                    case 43:
                    case 44:
                    case 45:
                    case 46:
                    case 47:
                    case 48:
                    case 49:
                    case 50:
                    case 51:
                    case 52:
                    case 53:
                    case 54:
                    case 55:
                    case 56:
                    case 57:
                    case 58:
                    case 59:
                    case 60:
                    case 61:
                    case 62:
                    case 64:
                    case 66:
                    case 67:
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 97:
                    case 98:
                    case 102:
                    case 103:
                    case 104:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    tryBlock_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) tryBlock_AST);
                }
                tryBlock_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_53);
                } else {
                    throw ex;
                }
            }
            this.returnAST = tryBlock_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forInit() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forInit_AST = null;
            try {
                boolean synPredMatched238 = false;
                if ((_tokenSet_55.member(this.mLA1)) && (_tokenSet_56.member(LA(2)))) {
                    int _m238 = mark();
                    synPredMatched238 = true;
                    this.inputState.guessing += 1;
                    try {
                        declaration();
                    } catch (RecognitionException pe) {
                        synPredMatched238 = false;
                    }
                    rewind(_m238);
                    this.inputState.guessing -= 1;
                }
                if (synPredMatched238) {
                    declaration();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if ((_tokenSet_57.member(this.mLA1)) && (_tokenSet_71.member(LA(2)))) {
                    expressionList();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                } else if (this.mLA1 != 63) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    forInit_AST = currentAST.root;
                    forInit_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(35, "FOR_INIT")).add(forInit_AST));
                    currentAST.root = forInit_AST;
                    currentAST.child = (((forInit_AST != null) && (forInit_AST.getFirstChild() != null)) ? forInit_AST.getFirstChild() : forInit_AST);

                    currentAST.advanceChildToEnd();
                }
                forInit_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forInit_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void traditionalForClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST traditionalForClause_AST = null;
            try {
                forInit();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(63);
                forCond();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(63);
                forIter();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                traditionalForClause_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = traditionalForClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forEachClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forEachClause_AST = null;
            AST p_AST = null;
            try {
                parameterDeclaration();
                p_AST = this.returnAST;
                this.astFactory.addASTChild(currentAST, this.returnAST);
                forEachColon();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                if (this.inputState.guessing == 0) {
                    forEachClause_AST = currentAST.root;
                    forEachClause_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(48, "FOR_EACH_CLAUSE")).add(forEachClause_AST));
                    currentAST.root = forEachClause_AST;
                    currentAST.child = (((forEachClause_AST != null) && (forEachClause_AST.getFirstChild() != null)) ? forEachClause_AST.getFirstChild() : forEachClause_AST);

                    currentAST.advanceChildToEnd();
                }
                forEachClause_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forEachClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forCond() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forCond_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                        break;
                    case 64:
                    case 65:
                    case 66:
                    case 67:
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    forCond_AST = currentAST.root;
                    forCond_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(36, "FOR_CONDITION")).add(forCond_AST));
                    currentAST.root = forCond_AST;
                    currentAST.child = (((forCond_AST != null) && (forCond_AST.getFirstChild() != null)) ? forCond_AST.getFirstChild() : forCond_AST);

                    currentAST.advanceChildToEnd();
                }
                forCond_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_7);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forCond_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forIter() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forIter_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 147:
                    case 148:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        expressionList();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 97:
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                if (this.inputState.guessing == 0) {
                    forIter_AST = currentAST.root;
                    forIter_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(37, "FOR_ITERATOR")).add(forIter_AST));
                    currentAST.root = forIter_AST;
                    currentAST.child = (((forIter_AST != null) && (forIter_AST.getFirstChild() != null)) ? forIter_AST.getFirstChild() : forIter_AST);

                    currentAST.advanceChildToEnd();
                }
                forIter_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forIter_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void forEachColon() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST forEachColon_AST = null;
            try {
                AST tmp178_AST = null;
                tmp178_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp178_AST);
                match(110);
                expression();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                forEachColon_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_22);
                } else {
                    throw ex;
                }
            }
            this.returnAST = forEachColon_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void aCase() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST aCase_AST = null;
            try {
                switch (this.mLA1) {
                    case 122:
                        AST tmp179_AST = null;
                        tmp179_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp179_AST);
                        match(122);
                        expression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 105:
                        AST tmp180_AST = null;
                        tmp180_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp180_AST);
                        match(105);
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                match(110);
                aCase_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_72);
                } else {
                    throw ex;
                }
            }
            this.returnAST = aCase_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void caseSList() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST caseSList_AST = null;
            Token caseColonToken = LT(0);
            try {
                while (_tokenSet_47.member(this.mLA1)) {
                    statement();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    caseSList_AST = currentAST.root;
                    caseSList_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(7, "SLIST")).add(caseSList_AST));
                    currentAST.root = caseSList_AST;
                    currentAST.child = (((caseSList_AST != null) && (caseSList_AST.getFirstChild() != null)) ? caseSList_AST.getFirstChild() : caseSList_AST);

                    currentAST.advanceChildToEnd();
                }
                if (this.inputState.guessing == 0) {
                    caseSList_AST = currentAST.root;

                    ASTImpl listAst = (ASTImpl) caseSList_AST;
                    if (listAst != null) {
                        listAst.setColumn(((TokenExt) caseColonToken).getEndColumn() + 1);
                        listAst.setLine(((TokenExt) caseColonToken).getEndLine());
                        TokenExt lastToken = (TokenExt) LT(0);
                        listAst.setEndColumn(lastToken.getEndColumn());
                        listAst.setEndLine(lastToken.getEndLine());
                    }
                }

                caseSList_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_70);
                } else {
                    throw ex;
                }
            }
            this.returnAST = caseSList_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void expressionList() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST expressionList_AST = null;
            Token firstToken = LT(1);
            try {
                expression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 74) {
                    match(74);
                    expression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                if (this.inputState.guessing == 0) {
                    expressionList_AST = currentAST.root;
                    expressionList_AST = this.astFactory.make(new ASTArray(2).add(this.astFactory.create(34, "ELIST")).add(expressionList_AST));
                    currentAST.root = expressionList_AST;
                    currentAST.child = (((expressionList_AST != null) && (expressionList_AST.getFirstChild() != null)) ? expressionList_AST.getFirstChild() : expressionList_AST);

                    currentAST.advanceChildToEnd();
                }

                if (this.inputState.guessing == 0) {
                    expressionList_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) expressionList_AST);
                }
                expressionList_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_73);
                } else {
                    throw ex;
                }
            }
            this.returnAST = expressionList_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void handler() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST handler_AST = null;
            Token firstToken = LT(1);
            try {
                AST tmp183_AST = null;
                tmp183_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp183_AST);
                match(125);
                match(96);
                parameterDeclaration();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                match(97);
                compoundStatement();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                if (this.inputState.guessing == 0) {
                    handler_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) handler_AST);
                }
                handler_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_74);
                } else {
                    throw ex;
                }
            }
            this.returnAST = handler_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void finallyClause() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST finallyClause_AST = null;
            Token firstToken = LT(1);
            try {
                AST tmp186_AST = null;
                tmp186_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp186_AST);
                match(124);
                compoundStatement();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                if (this.inputState.guessing == 0) {
                    finallyClause_AST = currentAST.root;
                    setLineColumn(firstToken, (ASTImpl) finallyClause_AST);
                }
                finallyClause_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_53);
                } else {
                    throw ex;
                }
            }
            this.returnAST = finallyClause_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void assignmentExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST assignmentExpression_AST = null;
            try {
                conditionalExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                switch (this.mLA1) {
                    case 98:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                        switch (this.mLA1) {
                            case 98:
                                AST tmp187_AST = null;
                                tmp187_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp187_AST);
                                match(98);
                                break;
                            case 126:
                                AST tmp188_AST = null;
                                tmp188_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp188_AST);
                                match(126);
                                break;
                            case 127:
                                AST tmp189_AST = null;
                                tmp189_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp189_AST);
                                match(127);
                                break;
                            case 128:
                                AST tmp190_AST = null;
                                tmp190_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp190_AST);
                                match(128);
                                break;
                            case 129:
                                AST tmp191_AST = null;
                                tmp191_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp191_AST);
                                match(129);
                                break;
                            case 130:
                                AST tmp192_AST = null;
                                tmp192_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp192_AST);
                                match(130);
                                break;
                            case 131:
                                AST tmp193_AST = null;
                                tmp193_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp193_AST);
                                match(131);
                                break;
                            case 132:
                                AST tmp194_AST = null;
                                tmp194_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp194_AST);
                                match(132);
                                break;
                            case 133:
                                AST tmp195_AST = null;
                                tmp195_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp195_AST);
                                match(133);
                                break;
                            case 134:
                                AST tmp196_AST = null;
                                tmp196_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp196_AST);
                                match(134);
                                break;
                            case 135:
                                AST tmp197_AST = null;
                                tmp197_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp197_AST);
                                match(135);
                                break;
                            case 136:
                                AST tmp198_AST = null;
                                tmp198_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp198_AST);
                                match(136);
                                break;
                            case 99:
                            case 100:
                            case 101:
                            case 102:
                            case 103:
                            case 104:
                            case 105:
                            case 106:
                            case 107:
                            case 108:
                            case 109:
                            case 110:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        assignmentExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 63:
                    case 67:
                    case 74:
                    case 97:
                    case 100:
                    case 110:
                        break;
                    case 64:
                    case 65:
                    case 66:
                    case 68:
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 73:
                    case 75:
                    case 76:
                    case 77:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 99:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 107:
                    case 108:
                    case 109:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                assignmentExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_65);
                } else {
                    throw ex;
                }
            }
            this.returnAST = assignmentExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void logicalOrExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST logicalOrExpression_AST = null;
            try {
                logicalAndExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 137) {
                    AST tmp199_AST = null;
                    tmp199_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp199_AST);
                    match(137);
                    logicalAndExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                logicalOrExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_75);
                } else {
                    throw ex;
                }
            }
            this.returnAST = logicalOrExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST logicalAndExpression_AST = null;
            try {
                inclusiveOrExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 138) {
                    AST tmp200_AST = null;
                    tmp200_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp200_AST);
                    match(138);
                    inclusiveOrExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                logicalAndExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_76);
                } else {
                    throw ex;
                }
            }
            this.returnAST = logicalAndExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST inclusiveOrExpression_AST = null;
            try {
                exclusiveOrExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 139) {
                    AST tmp201_AST = null;
                    tmp201_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp201_AST);
                    match(139);
                    exclusiveOrExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                inclusiveOrExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_77);
                } else {
                    throw ex;
                }
            }
            this.returnAST = inclusiveOrExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST exclusiveOrExpression_AST = null;
            try {
                andExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 140) {
                    AST tmp202_AST = null;
                    tmp202_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp202_AST);
                    match(140);
                    andExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                exclusiveOrExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_78);
                } else {
                    throw ex;
                }
            }
            this.returnAST = exclusiveOrExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void andExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST andExpression_AST = null;
            try {
                equalityExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (this.mLA1 == 104) {
                    AST tmp203_AST = null;
                    tmp203_AST = this.astFactory.create(LT(1));
                    this.astFactory.makeASTRoot(currentAST, tmp203_AST);
                    match(104);
                    equalityExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                andExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_79);
                } else {
                    throw ex;
                }
            }
            this.returnAST = andExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void equalityExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST equalityExpression_AST = null;
            try {
                relationalExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while ((this.mLA1 == 141) || (this.mLA1 == 142)) {
                    switch (this.mLA1) {
                        case 141:
                            AST tmp204_AST = null;
                            tmp204_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp204_AST);
                            match(141);
                            break;
                        case 142:
                            AST tmp205_AST = null;
                            tmp205_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp205_AST);
                            match(142);
                            break;
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                    relationalExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                equalityExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_80);
                } else {
                    throw ex;
                }
            }
            this.returnAST = equalityExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void relationalExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST relationalExpression_AST = null;
            try {
                shiftExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                boolean bLabel693 = false;
                switch (this.mLA1) {
                    case 63:
                    case 67:
                    case 70:
                    case 73:
                    case 74:
                    case 75:
                    case 97:
                    case 98:
                    case 100:
                    case 104:
                    case 110:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                        while (true) {
                            if (!_tokenSet_81.member(this.mLA1)) {
//                                break label693;
                                bLabel693 = true;
                                break;
                            }
                            switch (this.mLA1) {
                                case 73:
                                    AST tmp206_AST = null;
                                    tmp206_AST = this.astFactory.create(LT(1));
                                    this.astFactory.makeASTRoot(currentAST, tmp206_AST);
                                    match(73);
                                    break;
                                case 75:
                                    AST tmp207_AST = null;
                                    tmp207_AST = this.astFactory.create(LT(1));
                                    this.astFactory.makeASTRoot(currentAST, tmp207_AST);
                                    match(75);
                                    break;
                                case 143:
                                    AST tmp208_AST = null;
                                    tmp208_AST = this.astFactory.create(LT(1));
                                    this.astFactory.makeASTRoot(currentAST, tmp208_AST);
                                    match(143);
                                    break;
                                case 144:
                                    AST tmp209_AST = null;
                                    tmp209_AST = this.astFactory.create(LT(1));
                                    this.astFactory.makeASTRoot(currentAST, tmp209_AST);
                                    match(144);
                                    break;
                                default:
                                    throw new NoViableAltException(LT(1), getFilename());
                            }

                            shiftExpression();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        }
                    case 145:
                        if (bLabel693) break;
                        AST tmp210_AST = null;
                        tmp210_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp210_AST);
                        match(145);
                        typeSpec(true);
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 64:
                    case 65:
                    case 66:
                    case 68:
                    case 69:
                    case 71:
                    case 72:
                    case 76:
                    case 77:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 99:
                    case 101:
                    case 102:
                    case 103:
                    case 105:
                    case 106:
                    case 107:
                    case 108:
                    case 109:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    default:
                        if(bLabel693) break;
                        throw new NoViableAltException(LT(1), getFilename());
                }

                label693:
                relationalExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_82);
                } else {
                    throw ex;
                }
            }
            this.returnAST = relationalExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void shiftExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST shiftExpression_AST = null;
            try {
                additiveExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (_tokenSet_83.member(this.mLA1)) {
                    switch (this.mLA1) {
                        case 146:
                            AST tmp211_AST = null;
                            tmp211_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp211_AST);
                            match(146);
                            break;
                        case 76:
                            AST tmp212_AST = null;
                            tmp212_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp212_AST);
                            match(76);
                            break;
                        case 77:
                            AST tmp213_AST = null;
                            tmp213_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp213_AST);
                            match(77);
                            break;
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                    additiveExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                shiftExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_84);
                } else {
                    throw ex;
                }
            }
            this.returnAST = shiftExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void additiveExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST additiveExpression_AST = null;
            try {
                multiplicativeExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while ((this.mLA1 == 147) || (this.mLA1 == 148)) {
                    switch (this.mLA1) {
                        case 147:
                            AST tmp214_AST = null;
                            tmp214_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp214_AST);
                            match(147);
                            break;
                        case 148:
                            AST tmp215_AST = null;
                            tmp215_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp215_AST);
                            match(148);
                            break;
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                    multiplicativeExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                additiveExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_85);
                } else {
                    throw ex;
                }
            }
            this.returnAST = additiveExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST multiplicativeExpression_AST = null;
            try {
                unaryExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                while (_tokenSet_86.member(this.mLA1)) {
                    switch (this.mLA1) {
                        case 87:
                            AST tmp216_AST = null;
                            tmp216_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp216_AST);
                            match(87);
                            break;
                        case 149:
                            AST tmp217_AST = null;
                            tmp217_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp217_AST);
                            match(149);
                            break;
                        case 150:
                            AST tmp218_AST = null;
                            tmp218_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp218_AST);
                            match(150);
                            break;
                        default:
                            throw new NoViableAltException(LT(1), getFilename());
                    }

                    unaryExpression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                }

                multiplicativeExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_87);
                } else {
                    throw ex;
                }
            }
            this.returnAST = multiplicativeExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void unaryExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST unaryExpression_AST = null;
            try {
                switch (this.mLA1) {
                    case 151:
                        AST tmp219_AST = null;
                        tmp219_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp219_AST);
                        match(151);
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpression_AST = currentAST.root;
                        break;
                    case 152:
                        AST tmp220_AST = null;
                        tmp220_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp220_AST);
                        match(152);
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpression_AST = currentAST.root;
                        break;
                    case 148:
                        AST tmp221_AST = null;
                        tmp221_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp221_AST);
                        match(148);
                        if (this.inputState.guessing == 0) {
                            tmp221_AST.setType(31);
                        }
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpression_AST = currentAST.root;
                        break;
                    case 147:
                        AST tmp222_AST = null;
                        tmp222_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp222_AST);
                        match(147);
                        if (this.inputState.guessing == 0) {
                            tmp222_AST.setType(32);
                        }
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpression_AST = currentAST.root;
                        break;
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 153:
                    case 154:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        unaryExpressionNotPlusMinus();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpression_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 149:
                    case 150:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_88);
                } else {
                    throw ex;
                }
            }
            this.returnAST = unaryExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST unaryExpressionNotPlusMinus_AST = null;
            Token lpb = null;
            AST lpb_AST = null;
            Token lp = null;
            AST lp_AST = null;
            try {
                switch (this.mLA1) {
                    case 153:
                        AST tmp223_AST = null;
                        tmp223_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp223_AST);
                        match(153);
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpressionNotPlusMinus_AST = currentAST.root;
                        break;
                    case 154:
                        AST tmp224_AST = null;
                        tmp224_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp224_AST);
                        match(154);
                        unaryExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        unaryExpressionNotPlusMinus_AST = currentAST.root;
                        break;
                    case 68:
                    case 72:
                    case 73:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 96:
                    case 107:
                    case 155:
                    case 156:
                    case 157:
                    case 158:
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        boolean synPredMatched303 = false;
                        if ((this.mLA1 == 96) && (LA(2) >= 78) && (LA(2) <= 86)) {
                            int _m303 = mark();
                            synPredMatched303 = true;
                            this.inputState.guessing += 1;
                            try {
                                match(96);
                                builtInTypeSpec(true);
                                match(97);
                                unaryExpression();
                            } catch (RecognitionException pe) {
                                synPredMatched303 = false;
                            }
                            rewind(_m303);
                            this.inputState.guessing -= 1;
                        }
                        if (synPredMatched303) {
                            lpb = LT(1);
                            lpb_AST = this.astFactory.create(lpb);
                            this.astFactory.makeASTRoot(currentAST, lpb_AST);
                            match(96);
                            if (this.inputState.guessing == 0) {
                                lpb_AST.setType(23);
                            }
                            builtInTypeSpec(true);
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                            match(97);
                            if (this.inputState.guessing == 0) {
                                TokenExt lastToken = (TokenExt) LT(0);
                                ASTImpl ast = (ASTImpl) lpb_AST;
                                ast.setEndColumn(lastToken.getEndColumn());
                                ast.setEndLine(lastToken.getEndLine());
                            }

                            unaryExpression();
                            this.astFactory.addASTChild(currentAST, this.returnAST);
                        } else {
                            boolean synPredMatched305 = false;
                            if ((this.mLA1 == 96) && (LA(2) == 68)) {
                                int _m305 = mark();
                                synPredMatched305 = true;
                                this.inputState.guessing += 1;
                                try {
                                    match(96);
                                    classTypeSpec(true);
                                    match(97);
                                    unaryExpressionNotPlusMinus();
                                } catch (RecognitionException pe) {
                                    synPredMatched305 = false;
                                }
                                rewind(_m305);
                                this.inputState.guessing -= 1;
                            }
                            if (synPredMatched305) {
                                lp = LT(1);
                                lp_AST = this.astFactory.create(lp);
                                this.astFactory.makeASTRoot(currentAST, lp_AST);
                                match(96);
                                if (this.inputState.guessing == 0) {
                                    lp_AST.setType(23);
                                }
                                classTypeSpec(true);
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                match(97);
                                if (this.inputState.guessing == 0) {
                                    TokenExt lastToken = (TokenExt) LT(0);
                                    ASTImpl ast = (ASTImpl) lp_AST;
                                    ast.setEndColumn(lastToken.getEndColumn());
                                    ast.setEndLine(lastToken.getEndLine());
                                }

                                unaryExpressionNotPlusMinus();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                            } else if ((_tokenSet_89.member(this.mLA1)) && (_tokenSet_90.member(LA(2)))) {
                                postfixExpression();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                            } else {
                                throw new NoViableAltException(LT(1), getFilename());
                            }
                        }

                        unaryExpressionNotPlusMinus_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 147:
                    case 148:
                    case 149:
                    case 150:
                    case 151:
                    case 152:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_88);
                } else {
                    throw ex;
                }
            }
            this.returnAST = unaryExpressionNotPlusMinus_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void postfixExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST postfixExpression_AST = null;
            Token lp = null;
            AST lp_AST = null;
            Token lp3 = null;
            AST lp3_AST = null;
            Token lps = null;
            AST lps_AST = null;
            Token lb = null;
            AST lb_AST = null;
            Token in = null;
            AST in_AST = null;
            Token de = null;
            AST de_AST = null;
            try {
                primaryExpression();
                this.astFactory.addASTChild(currentAST, this.returnAST);
                while (true) {
                    if ((this.mLA1 == 69) && (((LA(2) == 68) || (LA(2) == 73)))) {
                        AST tmp227_AST = null;
                        tmp227_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp227_AST);
                        match(69);

                        switch (this.mLA1) {
                            case 73:
                                typeArguments();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 68:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        AST tmp228_AST = null;
                        tmp228_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp228_AST);
                        match(68);

                        switch (this.mLA1) {
                            case 96:
                                lp = LT(1);
                                lp_AST = this.astFactory.create(lp);
                                this.astFactory.makeASTRoot(currentAST, lp_AST);
                                match(96);
                                if (this.inputState.guessing == 0) {
                                    lp_AST.setType(27);
                                }
                                argList();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                match(97);
                                break;
                            case 63:
                            case 66:
                            case 67:
                            case 69:
                            case 70:
                            case 73:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 97:
                            case 98:
                            case 100:
                            case 104:
                            case 110:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 147:
                            case 148:
                            case 149:
                            case 150:
                            case 151:
                            case 152:
                                break;
                            case 64:
                            case 65:
                            case 68:
                            case 71:
                            case 72:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 95:
                            case 99:
                            case 101:
                            case 102:
                            case 103:
                            case 105:
                            case 106:
                            case 107:
                            case 108:
                            case 109:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                    }

                    if ((this.mLA1 == 69) && (LA(2) == 107)) {
                        AST tmp230_AST = null;
                        tmp230_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp230_AST);
                        match(69);
                        AST tmp231_AST = null;
                        tmp231_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp231_AST);
                        match(107);
                    }
                    if ((this.mLA1 == 69) && (LA(2) == 72)) {
                        AST tmp232_AST = null;
                        tmp232_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp232_AST);
                        match(69);
                        AST tmp233_AST = null;
                        tmp233_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp233_AST);
                        match(72);

                        switch (this.mLA1) {
                            case 96:
                                lp3 = LT(1);
                                lp3_AST = this.astFactory.create(lp3);
                                this.astFactory.makeASTRoot(currentAST, lp3_AST);
                                match(96);
                                argList();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                match(97);
                                if (this.inputState.guessing == 0) {
                                    lp3_AST.setType(42);
                                }
                                break;
                            case 69:
                                AST tmp235_AST = null;
                                tmp235_AST = this.astFactory.create(LT(1));
                                this.astFactory.makeASTRoot(currentAST, tmp235_AST);
                                match(69);

                                switch (this.mLA1) {
                                    case 73:
                                        typeArguments();
                                        this.astFactory.addASTChild(currentAST, this.returnAST);
                                        break;
                                    case 68:
                                        break;
                                    default:
                                        throw new NoViableAltException(LT(1), getFilename());
                                }

                                AST tmp236_AST = null;
                                tmp236_AST = this.astFactory.create(LT(1));
                                this.astFactory.addASTChild(currentAST, tmp236_AST);
                                match(68);

                                switch (this.mLA1) {
                                    case 96:
                                        lps = LT(1);
                                        lps_AST = this.astFactory.create(lps);
                                        this.astFactory.makeASTRoot(currentAST, lps_AST);
                                        match(96);
                                        if (this.inputState.guessing == 0) {
                                            lps_AST.setType(27);
                                        }
                                        argList();
                                        this.astFactory.addASTChild(currentAST, this.returnAST);
                                        match(97);
                                        break;
                                    case 63:
                                    case 66:
                                    case 67:
                                    case 69:
                                    case 70:
                                    case 73:
                                    case 74:
                                    case 75:
                                    case 76:
                                    case 77:
                                    case 87:
                                    case 97:
                                    case 98:
                                    case 100:
                                    case 104:
                                    case 110:
                                    case 126:
                                    case 127:
                                    case 128:
                                    case 129:
                                    case 130:
                                    case 131:
                                    case 132:
                                    case 133:
                                    case 134:
                                    case 135:
                                    case 136:
                                    case 137:
                                    case 138:
                                    case 139:
                                    case 140:
                                    case 141:
                                    case 142:
                                    case 143:
                                    case 144:
                                    case 145:
                                    case 146:
                                    case 147:
                                    case 148:
                                    case 149:
                                    case 150:
                                    case 151:
                                    case 152:
                                        break;
                                    case 64:
                                    case 65:
                                    case 68:
                                    case 71:
                                    case 72:
                                    case 78:
                                    case 79:
                                    case 80:
                                    case 81:
                                    case 82:
                                    case 83:
                                    case 84:
                                    case 85:
                                    case 86:
                                    case 88:
                                    case 89:
                                    case 90:
                                    case 91:
                                    case 92:
                                    case 93:
                                    case 94:
                                    case 95:
                                    case 99:
                                    case 101:
                                    case 102:
                                    case 103:
                                    case 105:
                                    case 106:
                                    case 107:
                                    case 108:
                                    case 109:
                                    case 111:
                                    case 112:
                                    case 113:
                                    case 114:
                                    case 115:
                                    case 116:
                                    case 117:
                                    case 118:
                                    case 119:
                                    case 120:
                                    case 121:
                                    case 122:
                                    case 123:
                                    case 124:
                                    case 125:
                                    default:
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                    }

                    if ((this.mLA1 == 69) && (LA(2) == 158)) {
                        AST tmp238_AST = null;
                        tmp238_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp238_AST);
                        match(69);
                        newExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                    }
                    if (this.mLA1 != 66) {
                        break;
                    }
                    lb = LT(1);
                    lb_AST = this.astFactory.create(lb);
                    this.astFactory.makeASTRoot(currentAST, lb_AST);
                    match(66);
                    if (this.inputState.guessing == 0) {
                        lb_AST.setType(24);
                    }
                    expression();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                    AST tmp239_AST = null;
                    tmp239_AST = this.astFactory.create(LT(1));
                    this.astFactory.addASTChild(currentAST, tmp239_AST);
                    match(67);
                }

                switch (this.mLA1) {
                    case 151:
                        in = LT(1);
                        in_AST = this.astFactory.create(in);
                        this.astFactory.makeASTRoot(currentAST, in_AST);
                        match(151);
                        if (this.inputState.guessing == 0) {
                            in_AST.setType(25);
                        }
                        break;
                    case 152:
                        de = LT(1);
                        de_AST = this.astFactory.create(de);
                        this.astFactory.makeASTRoot(currentAST, de_AST);
                        match(152);
                        if (this.inputState.guessing == 0) {
                            de_AST.setType(26);
                        }
                        break;
                    case 63:
                    case 67:
                    case 70:
                    case 73:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 97:
                    case 98:
                    case 100:
                    case 104:
                    case 110:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 147:
                    case 148:
                    case 149:
                    case 150:
                        break;
                    case 64:
                    case 65:
                    case 66:
                    case 68:
                    case 69:
                    case 71:
                    case 72:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 96:
                    case 99:
                    case 101:
                    case 102:
                    case 103:
                    case 105:
                    case 106:
                    case 107:
                    case 108:
                    case 109:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                postfixExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_88);
                } else {
                    throw ex;
                }
            }
            this.returnAST = postfixExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void primaryExpression() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST primaryExpression_AST = null;
            Token lp = null;
            AST lp_AST = null;
            Token lbt = null;
            AST lbt_AST = null;
            try {
                switch (this.mLA1) {
                    case 68:
                    case 73:
                        identPrimary();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        if ((this.mLA1 == 69) && (LA(2) == 101)) {
                            AST tmp240_AST = null;
                            tmp240_AST = this.astFactory.create(LT(1));
                            this.astFactory.makeASTRoot(currentAST, tmp240_AST);
                            match(69);
                            AST tmp241_AST = null;
                            tmp241_AST = this.astFactory.create(LT(1));
                            this.astFactory.addASTChild(currentAST, tmp241_AST);
                            match(101);
                        } else if ((!_tokenSet_64.member(this.mLA1)) || (!_tokenSet_91.member(LA(2)))) {
                            throw new NoViableAltException(LT(1), getFilename());
                        }

                        primaryExpression_AST = currentAST.root;
                        break;
                    case 159:
                    case 160:
                    case 161:
                    case 162:
                    case 163:
                    case 164:
                        constant();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 155:
                        AST tmp242_AST = null;
                        tmp242_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp242_AST);
                        match(155);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 156:
                        AST tmp243_AST = null;
                        tmp243_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp243_AST);
                        match(156);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 157:
                        AST tmp244_AST = null;
                        tmp244_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp244_AST);
                        match(157);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 158:
                        newExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 107:
                        AST tmp245_AST = null;
                        tmp245_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp245_AST);
                        match(107);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 72:
                        AST tmp246_AST = null;
                        tmp246_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp246_AST);
                        match(72);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 96:
                        lp = LT(1);
                        lp_AST = this.astFactory.create(lp);
                        this.astFactory.makeASTRoot(currentAST, lp_AST);
                        match(96);
                        assignmentExpression();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);
                        if (this.inputState.guessing == 0) {
                            TokenExt lastToken = (TokenExt) LT(0);
                            ASTImpl ast = (ASTImpl) lp_AST;
                            ast.setEndColumn(lastToken.getEndColumn());
                            ast.setEndLine(lastToken.getEndLine());
                        }
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        builtInType();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        while (this.mLA1 == 66) {
                            lbt = LT(1);
                            lbt_AST = this.astFactory.create(lbt);
                            this.astFactory.makeASTRoot(currentAST, lbt_AST);
                            match(66);
                            if (this.inputState.guessing == 0) {
                                lbt_AST.setType(17);
                            }
                            match(67);
                        }

                        AST tmp249_AST = null;
                        tmp249_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp249_AST);
                        match(69);
                        AST tmp250_AST = null;
                        tmp250_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp250_AST);
                        match(101);
                        primaryExpression_AST = currentAST.root;
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    case 87:
                    case 88:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 94:
                    case 95:
                    case 97:
                    case 98:
                    case 99:
                    case 100:
                    case 101:
                    case 102:
                    case 103:
                    case 104:
                    case 105:
                    case 106:
                    case 108:
                    case 109:
                    case 110:
                    case 111:
                    case 112:
                    case 113:
                    case 114:
                    case 115:
                    case 116:
                    case 117:
                    case 118:
                    case 119:
                    case 120:
                    case 121:
                    case 122:
                    case 123:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 128:
                    case 129:
                    case 130:
                    case 131:
                    case 132:
                    case 133:
                    case 134:
                    case 135:
                    case 136:
                    case 137:
                    case 138:
                    case 139:
                    case 140:
                    case 141:
                    case 142:
                    case 143:
                    case 144:
                    case 145:
                    case 146:
                    case 147:
                    case 148:
                    case 149:
                    case 150:
                    case 151:
                    case 152:
                    case 153:
                    case 154:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_64);
                } else {
                    throw ex;
                }
            }
            this.returnAST = primaryExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void newExpression()
            throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST newExpression_AST = null;
            Token firstToken = LT(1);
            try {
                AST tmp251_AST = null;
                tmp251_AST = this.astFactory.create(LT(1));
                this.astFactory.makeASTRoot(currentAST, tmp251_AST);
                match(158);

                switch (this.mLA1) {
                    case 73:
                        typeArguments();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        break;
                    case 68:
                    case 78:
                    case 79:
                    case 80:
                    case 81:
                    case 82:
                    case 83:
                    case 84:
                    case 85:
                    case 86:
                        break;
                    case 69:
                    case 70:
                    case 71:
                    case 72:
                    case 74:
                    case 75:
                    case 76:
                    case 77:
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                type();
                this.astFactory.addASTChild(currentAST, this.returnAST);

                switch (this.mLA1) {
                    case 96:
                        match(96);
                        argList();
                        this.astFactory.addASTChild(currentAST, this.returnAST);
                        match(97);

                        switch (this.mLA1) {
                            case 99:
                                classBlock();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 63:
                            case 66:
                            case 67:
                            case 69:
                            case 70:
                            case 73:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 97:
                            case 98:
                            case 100:
                            case 104:
                            case 110:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 147:
                            case 148:
                            case 149:
                            case 150:
                            case 151:
                            case 152:
                                break;
                            case 64:
                            case 65:
                            case 68:
                            case 71:
                            case 72:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 95:
                            case 96:
                            case 101:
                            case 102:
                            case 103:
                            case 105:
                            case 106:
                            case 107:
                            case 108:
                            case 109:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                    case 66:
                        newArrayDeclarator();
                        this.astFactory.addASTChild(currentAST, this.returnAST);

                        switch (this.mLA1) {
                            case 99:
                                arrayInitializer();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 63:
                            case 66:
                            case 67:
                            case 69:
                            case 70:
                            case 73:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 97:
                            case 98:
                            case 100:
                            case 104:
                            case 110:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 147:
                            case 148:
                            case 149:
                            case 150:
                            case 151:
                            case 152:
                                break;
                            case 64:
                            case 65:
                            case 68:
                            case 71:
                            case 72:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 95:
                            case 96:
                            case 101:
                            case 102:
                            case 103:
                            case 105:
                            case 106:
                            case 107:
                            case 108:
                            case 109:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                }


                if (this.inputState.guessing == 0) {
                    newExpression_AST = currentAST.root;

                    ASTImpl typeAst = (ASTImpl) newExpression_AST;
                    if (typeAst != null) {
                        typeAst.setColumn(firstToken.getColumn());
                        typeAst.setLine(firstToken.getLine());
                        Token lastToken = LT(1);
                        typeAst.setEndColumn(lastToken.getColumn());
                        typeAst.setEndLine(lastToken.getLine());
                    }
                    throw new NoViableAltException(LT(1), getFilename());
                }

                newExpression_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_64);
                } else {
                    throw ex;
                }
            }
            this.returnAST = newExpression_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void identPrimary()
            throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST identPrimary_AST = null;
            AST ta1_AST = null;
            AST ta2_AST = null;
            Token lp = null;
            AST lp_AST = null;
            Token lbc = null;
            AST lbc_AST = null;
            try {
                switch (this.mLA1) {
                    case 73:
                        typeArguments();
                        ta1_AST = this.returnAST;
                        break;
                    case 68:
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }

                AST tmp254_AST = null;
                tmp254_AST = this.astFactory.create(LT(1));
                this.astFactory.addASTChild(currentAST, tmp254_AST);
                match(68);
                while (true) {
                    boolean synPredMatched324 = false;
                    if ((this.mLA1 == 69) && (((LA(2) == 68) || (LA(2) == 73)))) {
                        int _m324 = mark();
                        synPredMatched324 = true;
                        this.inputState.guessing += 1;
                        try {
                            match(69);

                            switch (this.mLA1) {
                                case 73:
                                    typeArguments();
                                    break;
                                case 68:
                                    break;
                                default:
                                    throw new NoViableAltException(LT(1), getFilename());
                            }

                            match(68);
                        } catch (RecognitionException pe) {
                            synPredMatched324 = false;
                        }
                        rewind(_m324);
                        this.inputState.guessing -= 1;
                    }
                    if (synPredMatched324) {
                        AST tmp255_AST = null;
                        tmp255_AST = this.astFactory.create(LT(1));
                        this.astFactory.makeASTRoot(currentAST, tmp255_AST);
                        match(69);

                        switch (this.mLA1) {
                            case 73:
                                typeArguments();
                                ta2_AST = this.returnAST;
                                break;
                            case 68:
                                break;
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        AST tmp256_AST = null;
                        tmp256_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp256_AST);
                        match(68);
                    } else {
                        if ((!_tokenSet_92.member(this.mLA1)) || (!_tokenSet_91.member(LA(2)))) {
                            break;
                        }
                        break;
                    }

                }

                if (this.mLA1 == 96) {
                    lp = LT(1);
                    lp_AST = this.astFactory.create(lp);
                    this.astFactory.makeASTRoot(currentAST, lp_AST);
                    match(96);
                    if (this.inputState.guessing == 0) {
                        lp_AST.setType(27);
                    }
                    if ((this.inputState.guessing == 0) &&
                            (ta2_AST != null)) {
                        this.astFactory.addASTChild(currentAST, ta2_AST);
                    }

                    if ((this.inputState.guessing == 0) &&
                            (ta2_AST == null)) {
                        this.astFactory.addASTChild(currentAST, ta1_AST);
                    }

                    argList();
                    this.astFactory.addASTChild(currentAST, this.returnAST);
                    match(97);
                } else if ((this.mLA1 == 66) && (LA(2) == 67)) {
                    int _cnt330 = 0;
                    while (true) {
                        if ((this.mLA1 == 66) && (LA(2) == 67)) {
                            lbc = LT(1);
                            lbc_AST = this.astFactory.create(lbc);
                            this.astFactory.makeASTRoot(currentAST, lbc_AST);
                            match(66);
                            if (this.inputState.guessing == 0) {
                                lbc_AST.setType(17);
                            }
                            match(67);
                        } else {
                            if (_cnt330 >= 1) {
                                break;
                            }
                            throw new NoViableAltException(LT(1), getFilename());
                        }

                        ++_cnt330;
                    }

                } else if ((!_tokenSet_64.member(this.mLA1)) || (!_tokenSet_91.member(LA(2)))) {
                    throw new NoViableAltException(LT(1), getFilename());
                }

                identPrimary_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_64);
                } else {
                    throw ex;
                }
            }
            this.returnAST = identPrimary_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void constant() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST constant_AST = null;
            try {
                switch (this.mLA1) {
                    case 159:
                        AST tmp259_AST = null;
                        tmp259_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp259_AST);
                        match(159);
                        constant_AST = currentAST.root;
                        break;
                    case 160:
                        AST tmp260_AST = null;
                        tmp260_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp260_AST);
                        match(160);
                        constant_AST = currentAST.root;
                        break;
                    case 161:
                        AST tmp261_AST = null;
                        tmp261_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp261_AST);
                        match(161);
                        constant_AST = currentAST.root;
                        break;
                    case 162:
                        AST tmp262_AST = null;
                        tmp262_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp262_AST);
                        match(162);
                        constant_AST = currentAST.root;
                        break;
                    case 163:
                        AST tmp263_AST = null;
                        tmp263_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp263_AST);
                        match(163);
                        constant_AST = currentAST.root;
                        break;
                    case 164:
                        AST tmp264_AST = null;
                        tmp264_AST = this.astFactory.create(LT(1));
                        this.astFactory.addASTChild(currentAST, tmp264_AST);
                        match(164);
                        constant_AST = currentAST.root;
                        break;
                    default:
                        throw new NoViableAltException(LT(1), getFilename());
                }
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_64);
                } else {
                    throw ex;
                }
            }
            this.returnAST = constant_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
        ASTPair aPair = getNextASTPair();
        try {
            this.returnAST = null;
            ASTPair currentAST = aPair;
            AST newArrayDeclarator_AST = null;
            Token lb = null;
            AST lb_AST = null;
            try {
                int _cnt341 = 0;
                while (true) {
                    if ((this.mLA1 == 66) && (_tokenSet_93.member(LA(2)))) {
                        lb = LT(1);
                        lb_AST = this.astFactory.create(lb);
                        this.astFactory.makeASTRoot(currentAST, lb_AST);
                        match(66);
                        if (this.inputState.guessing == 0) {
                            lb_AST.setType(17);
                        }

                        switch (this.mLA1) {
                            case 68:
                            case 72:
                            case 73:
                            case 78:
                            case 79:
                            case 80:
                            case 81:
                            case 82:
                            case 83:
                            case 84:
                            case 85:
                            case 86:
                            case 96:
                            case 107:
                            case 147:
                            case 148:
                            case 151:
                            case 152:
                            case 153:
                            case 154:
                            case 155:
                            case 156:
                            case 157:
                            case 158:
                            case 159:
                            case 160:
                            case 161:
                            case 162:
                            case 163:
                            case 164:
                                expression();
                                this.astFactory.addASTChild(currentAST, this.returnAST);
                                break;
                            case 67:
                                break;
                            case 69:
                            case 70:
                            case 71:
                            case 74:
                            case 75:
                            case 76:
                            case 77:
                            case 87:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 93:
                            case 94:
                            case 95:
                            case 97:
                            case 98:
                            case 99:
                            case 100:
                            case 101:
                            case 102:
                            case 103:
                            case 104:
                            case 105:
                            case 106:
                            case 108:
                            case 109:
                            case 110:
                            case 111:
                            case 112:
                            case 113:
                            case 114:
                            case 115:
                            case 116:
                            case 117:
                            case 118:
                            case 119:
                            case 120:
                            case 121:
                            case 122:
                            case 123:
                            case 124:
                            case 125:
                            case 126:
                            case 127:
                            case 128:
                            case 129:
                            case 130:
                            case 131:
                            case 132:
                            case 133:
                            case 134:
                            case 135:
                            case 136:
                            case 137:
                            case 138:
                            case 139:
                            case 140:
                            case 141:
                            case 142:
                            case 143:
                            case 144:
                            case 145:
                            case 146:
                            case 149:
                            case 150:
                            default:
                                throw new NoViableAltException(LT(1), getFilename());
                        }

                        match(67);
                    } else {
                        if (_cnt341 >= 1) {
                            break;
                        }
                        throw new NoViableAltException(LT(1), getFilename());
                    }

                    ++_cnt341;
                }

                newArrayDeclarator_AST = currentAST.root;
            } catch (RecognitionException ex) {
                if (this.inputState.guessing == 0) {
                    reportError(ex);
                    consume();
                    consumeUntil(_tokenSet_94);
                } else {
                    throw ex;
                }
            }
            this.returnAST = newArrayDeclarator_AST;
        } finally {
            releaseASTPair(aPair);
        }
    }

    protected void buildTokenTypeASTClassMap() {
        this.tokenTypeToASTClassMap = null;
    }

    private static final long[] mk_tokenSet_0() {
        long[] data = {-9223368188564078590L, 966350864387L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_1() {
        long[] data = {-9223368188564078590L, 966350864402L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_2() {
        long[] data = {-9223368188564078592L, 966350864386L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_3() {
        long[] data = {2L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_4() {
        long[] data = {4611686018427387904L, 16L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_5() {
        long[] data = {-9223368188564078590L, 966350864386L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_6() {
        long[] data = {-4611682170136690688L, 1082323355154L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_7() {
        long[] data = {-9223372036854775808L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_8() {
        long[] data = {3848290697216L, 2130706434L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_9() {
        long[] data = {0L, 964228530704L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_10() {
        long[] data = {-9223368188564078590L, 1069438452242L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_11() {
        long[] data = {-9223368188564078590L, 1152792835968189202L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_12() {
        long[] data = {-9223372036854775808L, -4611579271310212008L, 32767L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_13() {
        long[] data = {-9223372036854775808L, -4611566038507586052L, 32767L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_14() {
        long[] data = {0L, 8372304L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_15() {
        long[] data = {-4611682170136690688L, -3458782106006585346L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_16() {
        long[] data = {-9223372036854775808L, -4611579267015244676L, 32767L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_17() {
        long[] data = {0L, 4294967300L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_18() {
        long[] data = {3848290697216L, 966359237138L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_19() {
        long[] data = {-4611682170136690688L, 1043668649490L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_20() {
        long[] data = {0L, 8836903584528L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_21() {
        long[] data = {0L, 9979373288308L, 137438952960L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_22() {
        long[] data = {0L, 8589934592L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_23() {
        long[] data = {-9223372036854775808L, 8589935616L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_24() {
        long[] data = {0L, 8589935616L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_25() {
        long[] data = {-9223372036854775808L, -4611615555193928696L, 511L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_26() {
        long[] data = {0L, 8802543846160L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_27() {
        long[] data = {0L, 68719477760L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_28() {
        long[] data = {0L, 4432406249472L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_29() {
        long[] data = {0L, 4432414621840L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_30() {
        long[] data = {0L, 34359738368L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_31() {
        long[] data = {-9223368188564078590L, -3458821688425185410L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_32() {
        long[] data = {0L, 4432414637200L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_33() {
        long[] data = {-9223368188564078592L, 5471779930806L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_34() {
        long[] data = {3848290697216L, 970654204470L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_35() {
        long[] data = {0L, 8372240L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_36() {
        long[] data = {0L, 564L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_37() {
        long[] data = {-9223372036854775808L, 17179870212L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_38() {
        long[] data = {-9223368188564078592L, 1069438452242L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_39() {
        long[] data = {-9223368188564078592L, 1035078713874L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_40() {
        long[] data = {-9223368188564078592L, 1035078713362L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_41() {
        long[] data = {-9223372036854775808L, 68719477760L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_42() {
        long[] data = {-9223372036854775808L, 90220083020800L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_43() {
        long[] data = {549755813888L, 2155855888L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_44() {
        long[] data = {0L, 2155856436L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_45() {
        long[] data = {0L, 35186527945268L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_46() {
        long[] data = {-9223372036854775808L, 34359738368L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_47() {
        long[] data = {-9223368188564078592L, 864277892463313682L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_48() {
        long[] data = {-9223368188564078592L, 4611557349788730130L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_49() {
        long[] data = {0L, 8796093022976L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_50() {
        long[] data = {0L, 4303339600L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_51() {
        long[] data = {-9223368188564078592L, 864277961182790418L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_52() {
        long[] data = {-9223368188564078592L, -3747335747166798986L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_53() {
        long[] data = {-9223368188564078592L, 1152792011334468370L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_54() {
        long[] data = {-9223368188564078592L, -57183194580106L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_55() {
        long[] data = {3848290697216L, 4286562322L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_56() {
        long[] data = {3848290697216L, 4286562870L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_57() {
        long[] data = {0L, 8800396362512L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_58() {
        long[] data = {-9223372036854775808L, -4611676101331125388L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_59() {
        long[] data = {3848290697216L, 141717143554L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_60() {
        long[] data = {3848290697216L, 141717143570L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_61() {
        long[] data = {-9223372036854775808L, 1024L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_62() {
        long[] data = {0L, 8903475577616L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_63() {
        long[] data = {0L, 8834756100880L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_64() {
        long[] data = {-9223372036854775808L, -4611614455673897364L, 33554431L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_65() {
        long[] data = {-9223372036854775808L, 70446053590024L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_66() {
        long[] data = {0L, 70377334113280L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_67() {
        long[] data = {-9223368188564078592L, 8804674552594L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_68() {
        long[] data = {-9223368188564078592L, -4611676097052934282L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_69() {
        long[] data = {0L, 79169140540176L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_70() {
        long[] data = {0L, 288232643894444032L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_71() {
        long[] data = {-9223372036854775808L, -4611676101331124364L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_72() {
        long[] data = {-9223368188564078592L, 1152510536357757714L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_73() {
        long[] data = {-9223372036854775808L, 8589934592L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_74() {
        long[] data = {-9223368188564078592L, 4611556525155009298L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_75() {
        long[] data = {-9223372036854775808L, -4611615555193928632L, 511L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_76() {
        long[] data = {-9223372036854775808L, -4611615555193928632L, 1023L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_77() {
        long[] data = {-9223372036854775808L, -4611615555193928632L, 2047L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_78() {
        long[] data = {-9223372036854775808L, -4611615555193928632L, 4095L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_79() {
        long[] data = {-9223372036854775808L, -4611615555193928632L, 8191L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_80() {
        long[] data = {-9223372036854775808L, -4611614455682300856L, 8191L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_81() {
        long[] data = {0L, 2560L, 98304L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_82() {
        long[] data = {-9223372036854775808L, -4611614455682300856L, 32767L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_83() {
        long[] data = {0L, 12288L, 262144L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_84() {
        long[] data = {-9223372036854775808L, -4611614455682298296L, 262143L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_85() {
        long[] data = {-9223372036854775808L, -4611614455682286008L, 524287L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_86() {
        long[] data = {0L, 8388608L, 6291456L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_87() {
        long[] data = {-9223372036854775808L, -4611614455682286008L, 2097151L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_88() {
        long[] data = {-9223372036854775808L, -4611614455673897400L, 8388607L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_89() {
        long[] data = {0L, 8800396362512L, 137304735744L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_90() {
        long[] data = {-9223372036854775808L, -4611605655277535364L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_91() {
        long[] data = {-4611682170136690688L, -3458821688425185410L, 137438953471L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_92() {
        long[] data = {-9223372036854775808L, -4611614451378930068L, 33554431L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_93() {
        long[] data = {0L, 8800396362520L, 137432137728L, 0L, 0L, 0L};
        return data;
    }

    private static final long[] mk_tokenSet_94() {
        long[] data = {-9223372036854775808L, -4611614421314158996L, 33554431L, 0L, 0L, 0L};
        return data;
    }
}
